drm_pagemap.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#ifndef _DRM_PAGEMAP_H_
#define _DRM_PAGEMAP_H_
 
#include <linux/dma-direction.h>
#include <linux/hmm.h>
#include <linux/memremap.h>
#include <linux/types.h>
 
#define NR_PAGES(order) (1U << (order))
 
struct dma_fence;
struct drm_pagemap;
struct drm_pagemap_cache;
struct drm_pagemap_dev_hold;
struct drm_pagemap_zdd;
struct device;
 
enum drm_interconnect_protocol {
    DRM_INTERCONNECT_SYSTEM,
    DRM_INTERCONNECT_DRIVER,
    /* A driver can add private values beyond DRM_INTERCONNECT_DRIVER */
};
 
struct drm_pagemap_addr {
    dma_addr_t addr;
    u64 proto : 54;
    u64 order : 8;
    u64 dir : 2;
};
 
static inline struct drm_pagemap_addr
drm_pagemap_addr_encode(dma_addr_t addr,
            enum drm_interconnect_protocol proto,
            unsigned int order,
            enum dma_data_direction dir)
{
    return (struct drm_pagemap_addr) {
        .addr = addr,
        .proto = proto,
        .order = order,
        .dir = dir,
    };
}
 
struct drm_pagemap_ops {
    struct drm_pagemap_addr (*device_map)(struct drm_pagemap *dpagemap,
                          struct device *dev,
                          struct page *page,
                          unsigned int order,
                          enum dma_data_direction dir);
 
    void (*device_unmap)(struct drm_pagemap *dpagemap,
                 struct device *dev,
                 const struct drm_pagemap_addr *addr);
 
    int (*populate_mm)(struct drm_pagemap *dpagemap,
               unsigned long start, unsigned long end,
               struct mm_struct *mm,
               unsigned long timeslice_ms);
    void (*destroy)(struct drm_pagemap *dpagemap,
            bool is_atomic_or_reclaim);
};
 
struct drm_pagemap {
    const struct drm_pagemap_ops *ops;
    struct kref ref;
    struct drm_device *drm;
    struct dev_pagemap *pagemap;
    struct drm_pagemap_dev_hold *dev_hold;
    struct drm_pagemap_cache *cache;
    struct list_head shrink_link;
};
 
struct drm_pagemap_devmem;
 
struct drm_pagemap_devmem_ops {
    void (*devmem_release)(struct drm_pagemap_devmem *devmem_allocation);
 
    int (*populate_devmem_pfn)(struct drm_pagemap_devmem *devmem_allocation,
                   unsigned long npages, unsigned long *pfn);
 
    int (*copy_to_devmem)(struct page **pages,
                  struct drm_pagemap_addr *pagemap_addr,
                  unsigned long npages,
                  struct dma_fence *pre_migrate_fence);
 
    int (*copy_to_ram)(struct page **pages,
               struct drm_pagemap_addr *pagemap_addr,
               unsigned long npages,
               struct dma_fence *pre_migrate_fence);
};
 
#if IS_ENABLED(CONFIG_ZONE_DEVICE)
 
int drm_pagemap_init(struct drm_pagemap *dpagemap,
             struct dev_pagemap *pagemap,
             struct drm_device *drm,
             const struct drm_pagemap_ops *ops);
 
struct drm_pagemap *drm_pagemap_create(struct drm_device *drm,
                       struct dev_pagemap *pagemap,
                       const struct drm_pagemap_ops *ops);
 
struct drm_pagemap *drm_pagemap_page_to_dpagemap(struct page *page);
 
void drm_pagemap_put(struct drm_pagemap *dpagemap);
 
#else
 
static inline struct drm_pagemap *drm_pagemap_page_to_dpagemap(struct page *page)
{
    return NULL;
}
 
static inline void drm_pagemap_put(struct drm_pagemap *dpagemap)
{
}
 
#endif /* IS_ENABLED(CONFIG_ZONE_DEVICE) */
 
static inline struct drm_pagemap *
drm_pagemap_get(struct drm_pagemap *dpagemap)
{
    if (likely(dpagemap))
        kref_get(&dpagemap->ref);
 
    return dpagemap;
}
 
static inline struct drm_pagemap * __must_check
drm_pagemap_get_unless_zero(struct drm_pagemap *dpagemap)
{
    return (dpagemap && kref_get_unless_zero(&dpagemap->ref)) ? dpagemap : NULL;
}
 
struct drm_pagemap_devmem {
    struct device *dev;
    struct mm_struct *mm;
    struct completion detached;
    const struct drm_pagemap_devmem_ops *ops;
    struct drm_pagemap *dpagemap;
    size_t size;
    u64 timeslice_expiration;
    struct dma_fence *pre_migrate_fence;
};
 
struct drm_pagemap_migrate_details {
    unsigned long timeslice_ms;
    u32 can_migrate_same_pagemap : 1;
};
 
#if IS_ENABLED(CONFIG_ZONE_DEVICE)
 
int drm_pagemap_migrate_to_devmem(struct drm_pagemap_devmem *devmem_allocation,
                  struct mm_struct *mm,
                  unsigned long start, unsigned long end,
                  const struct drm_pagemap_migrate_details *mdetails);
 
int drm_pagemap_evict_to_ram(struct drm_pagemap_devmem *devmem_allocation);
 
const struct dev_pagemap_ops *drm_pagemap_pagemap_ops_get(void);
 
void drm_pagemap_devmem_init(struct drm_pagemap_devmem *devmem_allocation,
                 struct device *dev, struct mm_struct *mm,
                 const struct drm_pagemap_devmem_ops *ops,
                 struct drm_pagemap *dpagemap, size_t size,
                 struct dma_fence *pre_migrate_fence);
 
int drm_pagemap_populate_mm(struct drm_pagemap *dpagemap,
                unsigned long start, unsigned long end,
                struct mm_struct *mm,
                unsigned long timeslice_ms);
 
void drm_pagemap_destroy(struct drm_pagemap *dpagemap, bool is_atomic_or_reclaim);
 
int drm_pagemap_reinit(struct drm_pagemap *dpagemap);
 
static inline struct drm_pagemap_zdd *drm_pagemap_page_zone_device_data(struct page *page)
{
    struct folio *folio = page_folio(page);
 
    return folio_zone_device_data(folio);
}
 
#else
 
static inline struct drm_pagemap_zdd *drm_pagemap_page_zone_device_data(struct page *page)
{
    return NULL;
}
 
#endif /* IS_ENABLED(CONFIG_ZONE_DEVICE) */
 
#endif