include/drm/drm_gpuvm.h

   1 /* SPDX-License-Identifier: GPL-2.0-only OR MIT */
   2
   3 #ifndef __DRM_GPUVM_H__
   4 #define __DRM_GPUVM_H__
   5
   6 /*
   7  * Copyright (c) 2022 Red Hat.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25  * OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #include <linux/list.h>
  29 #include <linux/rbtree.h>
  30 #include <linux/types.h>
  31
  32 #include <drm/drm_gem.h>
  33
  34 struct drm_gpuvm;
  35 struct drm_gpuvm_ops;
  36
  37 /**
  38  * enum drm_gpuva_flags - flags for struct drm_gpuva
  39  */
  40 enum drm_gpuva_flags {
  41         /**
  42          * @DRM_GPUVA_INVALIDATED:
  43          *
  44          * Flag indicating that the &drm_gpuva's backing GEM is invalidated.
  45          */
  46         DRM_GPUVA_INVALIDATED = (1 << 0),
  47
  48         /**
  49          * @DRM_GPUVA_SPARSE:
  50          *
  51          * Flag indicating that the &drm_gpuva is a sparse mapping.
  52          */
  53         DRM_GPUVA_SPARSE = (1 << 1),
  54
  55         /**
  56          * @DRM_GPUVA_USERBITS: user defined bits
  57          */
  58         DRM_GPUVA_USERBITS = (1 << 2),
  59 };
  60
  61 /**
  62  * struct drm_gpuva - structure to track a GPU VA mapping
  63  *
  64  * This structure represents a GPU VA mapping and is associated with a
  65  * &drm_gpuvm.
  66  *
  67  * Typically, this structure is embedded in bigger driver structures.
  68  */
  69 struct drm_gpuva {
  70         /**
  71          * @vm: the &drm_gpuvm this object is associated with
  72          */
  73         struct drm_gpuvm *vm;
  74
  75         /**
  76          * @flags: the &drm_gpuva_flags for this mapping
  77          */
  78         enum drm_gpuva_flags flags;
  79
  80         /**
  81          * @va: structure containing the address and range of the &drm_gpuva
  82          */
  83         struct {
  84                 /**
  85                  * @addr: the start address
  86                  */
  87                 u64 addr;
  88
  89                 /*
  90                  * @range: the range
  91                  */
  92                 u64 range;
  93         } va;
  94
  95         /**
  96          * @gem: structure containing the &drm_gem_object and it's offset
  97          */
  98         struct {
  99                 /**
 100                  * @offset: the offset within the &drm_gem_object
 101                  */
 102                 u64 offset;
 103
 104                 /**
 105                  * @obj: the mapped &drm_gem_object
 106                  */
 107                 struct drm_gem_object *obj;
 108
 109                 /**
 110                  * @entry: the &list_head to attach this object to a &drm_gem_object
 111                  */
 112                 struct list_head entry;
 113         } gem;
 114
 115         /**
 116          * @rb: structure containing data to store &drm_gpuvas in a rb-tree
 117          */
 118         struct {
 119                 /**
 120                  * @rb: the rb-tree node
 121                  */
 122                 struct rb_node node;
 123
 124                 /**
 125                  * @entry: The &list_head to additionally connect &drm_gpuvas
 126                  * in the same order they appear in the interval tree. This is
 127                  * useful to keep iterating &drm_gpuvas from a start node found
 128                  * through the rb-tree while doing modifications on the rb-tree
 129                  * itself.
 130                  */
 131                 struct list_head entry;
 132
 133                 /**
 134                  * @__subtree_last: needed by the interval tree, holding last-in-subtree
 135                  */
 136                 u64 __subtree_last;
 137         } rb;
 138 };
 139
 140 int drm_gpuva_insert(struct drm_gpuvm *gpuvm, struct drm_gpuva *va);
 141 void drm_gpuva_remove(struct drm_gpuva *va);
 142
 143 void drm_gpuva_link(struct drm_gpuva *va);
 144 void drm_gpuva_unlink(struct drm_gpuva *va);
 145
 146 struct drm_gpuva *drm_gpuva_find(struct drm_gpuvm *gpuvm,
 147                                  u64 addr, u64 range);
 148 struct drm_gpuva *drm_gpuva_find_first(struct drm_gpuvm *gpuvm,
 149                                        u64 addr, u64 range);
 150 struct drm_gpuva *drm_gpuva_find_prev(struct drm_gpuvm *gpuvm, u64 start);
 151 struct drm_gpuva *drm_gpuva_find_next(struct drm_gpuvm *gpuvm, u64 end);
 152
 153 static inline void drm_gpuva_init(struct drm_gpuva *va, u64 addr, u64 range,
 154                                   struct drm_gem_object *obj, u64 offset)
 155 {
 156         va->va.addr = addr;
 157         va->va.range = range;
 158         va->gem.obj = obj;
 159         va->gem.offset = offset;
 160 }
 161
 162 /**
 163  * drm_gpuva_invalidate() - sets whether the backing GEM of this &drm_gpuva is
 164  * invalidated
 165  * @va: the &drm_gpuva to set the invalidate flag for
 166  * @invalidate: indicates whether the &drm_gpuva is invalidated
 167  */
 168 static inline void drm_gpuva_invalidate(struct drm_gpuva *va, bool invalidate)
 169 {
 170         if (invalidate)
 171                 va->flags |= DRM_GPUVA_INVALIDATED;
 172         else
 173                 va->flags &= ~DRM_GPUVA_INVALIDATED;
 174 }
 175
 176 /**
 177  * drm_gpuva_invalidated() - indicates whether the backing BO of this &drm_gpuva
 178  * is invalidated
 179  * @va: the &drm_gpuva to check
 180  */
 181 static inline bool drm_gpuva_invalidated(struct drm_gpuva *va)
 182 {
 183         return va->flags & DRM_GPUVA_INVALIDATED;
 184 }
 185
 186 /**
 187  * struct drm_gpuvm - DRM GPU VA Manager
 188  *
 189  * The DRM GPU VA Manager keeps track of a GPU's virtual address space by using
 190  * &maple_tree structures. Typically, this structure is embedded in bigger
 191  * driver structures.
 192  *
 193  * Drivers can pass addresses and ranges in an arbitrary unit, e.g. bytes or
 194  * pages.
 195  *
 196  * There should be one manager instance per GPU virtual address space.
 197  */
 198 struct drm_gpuvm {
 199         /**
 200          * @name: the name of the DRM GPU VA space
 201          */
 202         const char *name;
 203
 204         /**
 205          * @mm_start: start of the VA space
 206          */
 207         u64 mm_start;
 208
 209         /**
 210          * @mm_range: length of the VA space
 211          */
 212         u64 mm_range;
 213
 214         /**
 215          * @rb: structures to track &drm_gpuva entries
 216          */
 217         struct {
 218                 /**
 219                  * @tree: the rb-tree to track GPU VA mappings
 220                  */
 221                 struct rb_root_cached tree;
 222
 223                 /**
 224                  * @list: the &list_head to track GPU VA mappings
 225                  */
 226                 struct list_head list;
 227         } rb;
 228
 229         /**
 230          * @kernel_alloc_node:
 231          *
 232          * &drm_gpuva representing the address space cutout reserved for
 233          * the kernel
 234          */
 235         struct drm_gpuva kernel_alloc_node;
 236
 237         /**
 238          * @ops: &drm_gpuvm_ops providing the split/merge steps to drivers
 239          */
 240         const struct drm_gpuvm_ops *ops;
 241 };
 242
 243 void drm_gpuvm_init(struct drm_gpuvm *gpuvm, const char *name,
 244                     u64 start_offset, u64 range,
 245                     u64 reserve_offset, u64 reserve_range,
 246                     const struct drm_gpuvm_ops *ops);
 247 void drm_gpuvm_destroy(struct drm_gpuvm *gpuvm);
 248
 249 bool drm_gpuvm_interval_empty(struct drm_gpuvm *gpuvm, u64 addr, u64 range);
 250
 251 static inline struct drm_gpuva *
 252 __drm_gpuva_next(struct drm_gpuva *va)
 253 {
 254         if (va && !list_is_last(&va->rb.entry, &va->vm->rb.list))
 255                 return list_next_entry(va, rb.entry);
 256
 257         return NULL;
 258 }
 259
 260 /**
 261  * drm_gpuvm_for_each_va_range() - iterate over a range of &drm_gpuvas
 262  * @va__: &drm_gpuva structure to assign to in each iteration step
 263  * @gpuvm__: &drm_gpuvm to walk over
 264  * @start__: starting offset, the first gpuva will overlap this
 265  * @end__: ending offset, the last gpuva will start before this (but may
 266  * overlap)
 267  *
 268  * This iterator walks over all &drm_gpuvas in the &drm_gpuvm that lie
 269  * between @start__ and @end__. It is implemented similarly to list_for_each(),
 270  * but is using the &drm_gpuvm's internal interval tree to accelerate
 271  * the search for the starting &drm_gpuva, and hence isn't safe against removal
 272  * of elements. It assumes that @end__ is within (or is the upper limit of) the
 273  * &drm_gpuvm. This iterator does not skip over the &drm_gpuvm's
 274  * @kernel_alloc_node.
 275  */
 276 #define drm_gpuvm_for_each_va_range(va__, gpuvm__, start__, end__) \
 277         for (va__ = drm_gpuva_find_first((gpuvm__), (start__), (end__) - (start__)); \
 278              va__ && (va__->va.addr < (end__)); \
 279              va__ = __drm_gpuva_next(va__))
 280
 281 /**
 282  * drm_gpuvm_for_each_va_range_safe() - safely iterate over a range of
 283  * &drm_gpuvas
 284  * @va__: &drm_gpuva to assign to in each iteration step
 285  * @next__: another &drm_gpuva to use as temporary storage
 286  * @gpuvm__: &drm_gpuvm to walk over
 287  * @start__: starting offset, the first gpuva will overlap this
 288  * @end__: ending offset, the last gpuva will start before this (but may
 289  * overlap)
 290  *
 291  * This iterator walks over all &drm_gpuvas in the &drm_gpuvm that lie
 292  * between @start__ and @end__. It is implemented similarly to
 293  * list_for_each_safe(), but is using the &drm_gpuvm's internal interval
 294  * tree to accelerate the search for the starting &drm_gpuva, and hence is safe
 295  * against removal of elements. It assumes that @end__ is within (or is the
 296  * upper limit of) the &drm_gpuvm. This iterator does not skip over the
 297  * &drm_gpuvm's @kernel_alloc_node.
 298  */
 299 #define drm_gpuvm_for_each_va_range_safe(va__, next__, gpuvm__, start__, end__) \
 300         for (va__ = drm_gpuva_find_first((gpuvm__), (start__), (end__) - (start__)), \
 301              next__ = __drm_gpuva_next(va__); \
 302              va__ && (va__->va.addr < (end__)); \
 303              va__ = next__, next__ = __drm_gpuva_next(va__))
 304
 305 /**
 306  * drm_gpuvm_for_each_va() - iterate over all &drm_gpuvas
 307  * @va__: &drm_gpuva to assign to in each iteration step
 308  * @gpuvm__: &drm_gpuvm to walk over
 309  *
 310  * This iterator walks over all &drm_gpuva structures associated with the given
 311  * &drm_gpuvm.
 312  */
 313 #define drm_gpuvm_for_each_va(va__, gpuvm__) \
 314         list_for_each_entry(va__, &(gpuvm__)->rb.list, rb.entry)
 315
 316 /**
 317  * drm_gpuvm_for_each_va_safe() - safely iterate over all &drm_gpuvas
 318  * @va__: &drm_gpuva to assign to in each iteration step
 319  * @next__: another &drm_gpuva to use as temporary storage
 320  * @gpuvm__: &drm_gpuvm to walk over
 321  *
 322  * This iterator walks over all &drm_gpuva structures associated with the given
 323  * &drm_gpuvm. It is implemented with list_for_each_entry_safe(), and
 324  * hence safe against the removal of elements.
 325  */
 326 #define drm_gpuvm_for_each_va_safe(va__, next__, gpuvm__) \
 327         list_for_each_entry_safe(va__, next__, &(gpuvm__)->rb.list, rb.entry)
 328
 329 /**
 330  * enum drm_gpuva_op_type - GPU VA operation type
 331  *
 332  * Operations to alter the GPU VA mappings tracked by the &drm_gpuvm.
 333  */
 334 enum drm_gpuva_op_type {
 335         /**
 336          * @DRM_GPUVA_OP_MAP: the map op type
 337          */
 338         DRM_GPUVA_OP_MAP,
 339
 340         /**
 341          * @DRM_GPUVA_OP_REMAP: the remap op type
 342          */
 343         DRM_GPUVA_OP_REMAP,
 344
 345         /**
 346          * @DRM_GPUVA_OP_UNMAP: the unmap op type
 347          */
 348         DRM_GPUVA_OP_UNMAP,
 349
 350         /**
 351          * @DRM_GPUVA_OP_PREFETCH: the prefetch op type
 352          */
 353         DRM_GPUVA_OP_PREFETCH,
 354 };
 355
 356 /**
 357  * struct drm_gpuva_op_map - GPU VA map operation
 358  *
 359  * This structure represents a single map operation generated by the
 360  * DRM GPU VA manager.
 361  */
 362 struct drm_gpuva_op_map {
 363         /**
 364          * @va: structure containing address and range of a map
 365          * operation
 366          */
 367         struct {
 368                 /**
 369                  * @addr: the base address of the new mapping
 370                  */
 371                 u64 addr;
 372
 373                 /**
 374                  * @range: the range of the new mapping
 375                  */
 376                 u64 range;
 377         } va;
 378
 379         /**
 380          * @gem: structure containing the &drm_gem_object and it's offset
 381          */
 382         struct {
 383                 /**
 384                  * @offset: the offset within the &drm_gem_object
 385                  */
 386                 u64 offset;
 387
 388                 /**
 389                  * @obj: the &drm_gem_object to map
 390                  */
 391                 struct drm_gem_object *obj;
 392         } gem;
 393 };
 394
 395 /**
 396  * struct drm_gpuva_op_unmap - GPU VA unmap operation
 397  *
 398  * This structure represents a single unmap operation generated by the
 399  * DRM GPU VA manager.
 400  */
 401 struct drm_gpuva_op_unmap {
 402         /**
 403          * @va: the &drm_gpuva to unmap
 404          */
 405         struct drm_gpuva *va;
 406
 407         /**
 408          * @keep:
 409          *
 410          * Indicates whether this &drm_gpuva is physically contiguous with the
 411          * original mapping request.
 412          *
 413          * Optionally, if &keep is set, drivers may keep the actual page table
 414          * mappings for this &drm_gpuva, adding the missing page table entries
 415          * only and update the &drm_gpuvm accordingly.
 416          */
 417         bool keep;
 418 };
 419
 420 /**
 421  * struct drm_gpuva_op_remap - GPU VA remap operation
 422  *
 423  * This represents a single remap operation generated by the DRM GPU VA manager.
 424  *
 425  * A remap operation is generated when an existing GPU VA mmapping is split up
 426  * by inserting a new GPU VA mapping or by partially unmapping existent
 427  * mapping(s), hence it consists of a maximum of two map and one unmap
 428  * operation.
 429  *
 430  * The @unmap operation takes care of removing the original existing mapping.
 431  * @prev is used to remap the preceding part, @next the subsequent part.
 432  *
 433  * If either a new mapping's start address is aligned with the start address
 434  * of the old mapping or the new mapping's end address is aligned with the
 435  * end address of the old mapping, either @prev or @next is NULL.
 436  *
 437  * Note, the reason for a dedicated remap operation, rather than arbitrary
 438  * unmap and map operations, is to give drivers the chance of extracting driver
 439  * specific data for creating the new mappings from the unmap operations's
 440  * &drm_gpuva structure which typically is embedded in larger driver specific
 441  * structures.
 442  */
 443 struct drm_gpuva_op_remap {
 444         /**
 445          * @prev: the preceding part of a split mapping
 446          */
 447         struct drm_gpuva_op_map *prev;
 448
 449         /**
 450          * @next: the subsequent part of a split mapping
 451          */
 452         struct drm_gpuva_op_map *next;
 453
 454         /**
 455          * @unmap: the unmap operation for the original existing mapping
 456          */
 457         struct drm_gpuva_op_unmap *unmap;
 458 };
 459
 460 /**
 461  * struct drm_gpuva_op_prefetch - GPU VA prefetch operation
 462  *
 463  * This structure represents a single prefetch operation generated by the
 464  * DRM GPU VA manager.
 465  */
 466 struct drm_gpuva_op_prefetch {
 467         /**
 468          * @va: the &drm_gpuva to prefetch
 469          */
 470         struct drm_gpuva *va;
 471 };
 472
 473 /**
 474  * struct drm_gpuva_op - GPU VA operation
 475  *
 476  * This structure represents a single generic operation.
 477  *
 478  * The particular type of the operation is defined by @op.
 479  */
 480 struct drm_gpuva_op {
 481         /**
 482          * @entry:
 483          *
 484          * The &list_head used to distribute instances of this struct within
 485          * &drm_gpuva_ops.
 486          */
 487         struct list_head entry;
 488
 489         /**
 490          * @op: the type of the operation
 491          */
 492         enum drm_gpuva_op_type op;
 493
 494         union {
 495                 /**
 496                  * @map: the map operation
 497                  */
 498                 struct drm_gpuva_op_map map;
 499
 500                 /**
 501                  * @remap: the remap operation
 502                  */
 503                 struct drm_gpuva_op_remap remap;
 504
 505                 /**
 506                  * @unmap: the unmap operation
 507                  */
 508                 struct drm_gpuva_op_unmap unmap;
 509
 510                 /**
 511                  * @prefetch: the prefetch operation
 512                  */
 513                 struct drm_gpuva_op_prefetch prefetch;
 514         };
 515 };
 516
 517 /**
 518  * struct drm_gpuva_ops - wraps a list of &drm_gpuva_op
 519  */
 520 struct drm_gpuva_ops {
 521         /**
 522          * @list: the &list_head
 523          */
 524         struct list_head list;
 525 };
 526
 527 /**
 528  * drm_gpuva_for_each_op() - iterator to walk over &drm_gpuva_ops
 529  * @op: &drm_gpuva_op to assign in each iteration step
 530  * @ops: &drm_gpuva_ops to walk
 531  *
 532  * This iterator walks over all ops within a given list of operations.
 533  */
 534 #define drm_gpuva_for_each_op(op, ops) list_for_each_entry(op, &(ops)->list, entry)
 535
 536 /**
 537  * drm_gpuva_for_each_op_safe() - iterator to safely walk over &drm_gpuva_ops
 538  * @op: &drm_gpuva_op to assign in each iteration step
 539  * @next: &next &drm_gpuva_op to store the next step
 540  * @ops: &drm_gpuva_ops to walk
 541  *
 542  * This iterator walks over all ops within a given list of operations. It is
 543  * implemented with list_for_each_safe(), so save against removal of elements.
 544  */
 545 #define drm_gpuva_for_each_op_safe(op, next, ops) \
 546         list_for_each_entry_safe(op, next, &(ops)->list, entry)
 547
 548 /**
 549  * drm_gpuva_for_each_op_from_reverse() - iterate backwards from the given point
 550  * @op: &drm_gpuva_op to assign in each iteration step
 551  * @ops: &drm_gpuva_ops to walk
 552  *
 553  * This iterator walks over all ops within a given list of operations beginning
 554  * from the given operation in reverse order.
 555  */
 556 #define drm_gpuva_for_each_op_from_reverse(op, ops) \
 557         list_for_each_entry_from_reverse(op, &(ops)->list, entry)
 558
 559 /**
 560  * drm_gpuva_first_op() - returns the first &drm_gpuva_op from &drm_gpuva_ops
 561  * @ops: the &drm_gpuva_ops to get the fist &drm_gpuva_op from
 562  */
 563 #define drm_gpuva_first_op(ops) \
 564         list_first_entry(&(ops)->list, struct drm_gpuva_op, entry)
 565
 566 /**
 567  * drm_gpuva_last_op() - returns the last &drm_gpuva_op from &drm_gpuva_ops
 568  * @ops: the &drm_gpuva_ops to get the last &drm_gpuva_op from
 569  */
 570 #define drm_gpuva_last_op(ops) \
 571         list_last_entry(&(ops)->list, struct drm_gpuva_op, entry)
 572
 573 /**
 574  * drm_gpuva_prev_op() - previous &drm_gpuva_op in the list
 575  * @op: the current &drm_gpuva_op
 576  */
 577 #define drm_gpuva_prev_op(op) list_prev_entry(op, entry)
 578
 579 /**
 580  * drm_gpuva_next_op() - next &drm_gpuva_op in the list
 581  * @op: the current &drm_gpuva_op
 582  */
 583 #define drm_gpuva_next_op(op) list_next_entry(op, entry)
 584
 585 struct drm_gpuva_ops *
 586 drm_gpuvm_sm_map_ops_create(struct drm_gpuvm *gpuvm,
 587                             u64 addr, u64 range,
 588                             struct drm_gem_object *obj, u64 offset);
 589 struct drm_gpuva_ops *
 590 drm_gpuvm_sm_unmap_ops_create(struct drm_gpuvm *gpuvm,
 591                               u64 addr, u64 range);
 592
 593 struct drm_gpuva_ops *
 594 drm_gpuvm_prefetch_ops_create(struct drm_gpuvm *gpuvm,
 595                                  u64 addr, u64 range);
 596
 597 struct drm_gpuva_ops *
 598 drm_gpuvm_gem_unmap_ops_create(struct drm_gpuvm *gpuvm,
 599                                struct drm_gem_object *obj);
 600
 601 void drm_gpuva_ops_free(struct drm_gpuvm *gpuvm,
 602                         struct drm_gpuva_ops *ops);
 603
 604 static inline void drm_gpuva_init_from_op(struct drm_gpuva *va,
 605                                           struct drm_gpuva_op_map *op)
 606 {
 607         drm_gpuva_init(va, op->va.addr, op->va.range,
 608                        op->gem.obj, op->gem.offset);
 609 }
 610
 611 /**
 612  * struct drm_gpuvm_ops - callbacks for split/merge steps
 613  *
 614  * This structure defines the callbacks used by &drm_gpuvm_sm_map and
 615  * &drm_gpuvm_sm_unmap to provide the split/merge steps for map and unmap
 616  * operations to drivers.
 617  */
 618 struct drm_gpuvm_ops {
 619         /**
 620          * @op_alloc: called when the &drm_gpuvm allocates
 621          * a struct drm_gpuva_op
 622          *
 623          * Some drivers may want to embed struct drm_gpuva_op into driver
 624          * specific structures. By implementing this callback drivers can
 625          * allocate memory accordingly.
 626          *
 627          * This callback is optional.
 628          */
 629         struct drm_gpuva_op *(*op_alloc)(void);
 630
 631         /**
 632          * @op_free: called when the &drm_gpuvm frees a
 633          * struct drm_gpuva_op
 634          *
 635          * Some drivers may want to embed struct drm_gpuva_op into driver
 636          * specific structures. By implementing this callback drivers can
 637          * free the previously allocated memory accordingly.
 638          *
 639          * This callback is optional.
 640          */
 641         void (*op_free)(struct drm_gpuva_op *op);
 642
 643         /**
 644          * @sm_step_map: called from &drm_gpuvm_sm_map to finally insert the
 645          * mapping once all previous steps were completed
 646          *
 647          * The &priv pointer matches the one the driver passed to
 648          * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
 649          *
 650          * Can be NULL if &drm_gpuvm_sm_map is used.
 651          */
 652         int (*sm_step_map)(struct drm_gpuva_op *op, void *priv);
 653
 654         /**
 655          * @sm_step_remap: called from &drm_gpuvm_sm_map and
 656          * &drm_gpuvm_sm_unmap to split up an existent mapping
 657          *
 658          * This callback is called when existent mapping needs to be split up.
 659          * This is the case when either a newly requested mapping overlaps or
 660          * is enclosed by an existent mapping or a partial unmap of an existent
 661          * mapping is requested.
 662          *
 663          * The &priv pointer matches the one the driver passed to
 664          * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
 665          *
 666          * Can be NULL if neither &drm_gpuvm_sm_map nor &drm_gpuvm_sm_unmap is
 667          * used.
 668          */
 669         int (*sm_step_remap)(struct drm_gpuva_op *op, void *priv);
 670
 671         /**
 672          * @sm_step_unmap: called from &drm_gpuvm_sm_map and
 673          * &drm_gpuvm_sm_unmap to unmap an existent mapping
 674          *
 675          * This callback is called when existent mapping needs to be unmapped.
 676          * This is the case when either a newly requested mapping encloses an
 677          * existent mapping or an unmap of an existent mapping is requested.
 678          *
 679          * The &priv pointer matches the one the driver passed to
 680          * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
 681          *
 682          * Can be NULL if neither &drm_gpuvm_sm_map nor &drm_gpuvm_sm_unmap is
 683          * used.
 684          */
 685         int (*sm_step_unmap)(struct drm_gpuva_op *op, void *priv);
 686 };
 687
 688 int drm_gpuvm_sm_map(struct drm_gpuvm *gpuvm, void *priv,
 689                      u64 addr, u64 range,
 690                      struct drm_gem_object *obj, u64 offset);
 691
 692 int drm_gpuvm_sm_unmap(struct drm_gpuvm *gpuvm, void *priv,
 693                        u64 addr, u64 range);
 694
 695 void drm_gpuva_map(struct drm_gpuvm *gpuvm,
 696                    struct drm_gpuva *va,
 697                    struct drm_gpuva_op_map *op);
 698
 699 void drm_gpuva_remap(struct drm_gpuva *prev,
 700                      struct drm_gpuva *next,
 701                      struct drm_gpuva_op_remap *op);
 702
 703 void drm_gpuva_unmap(struct drm_gpuva_op_unmap *op);
 704
 705 #endif /* __DRM_GPUVM_H__ */