This is a more descriptive name.
Signed-off-by: Rob Clark <robdclark@chromium.org>
Reviewed-by: Dmitry Baryshkov <dmitry.baryshkov@oss.qualcomm.com>
Signed-off-by: Rob Clark <robin.clark@oss.qualcomm.com>
Tested-by: Antonino Maniscalco <antomani103@gmail.com>
Reviewed-by: Antonino Maniscalco <antomani103@gmail.com>
Patchwork: https://patchwork.freedesktop.org/patch/661459/
                struct msm_ringbuffer *ring, struct msm_gem_submit *submit)
 {
        bool sysprof = refcount_read(&a6xx_gpu->base.base.sysprof_active) > 1;
-       struct msm_file_private *ctx = submit->queue->ctx;
+       struct msm_context *ctx = submit->queue->ctx;
        struct adreno_gpu *adreno_gpu = &a6xx_gpu->base;
        phys_addr_t ttbr;
        u32 asid;
 
        return 0;
 }
 
-int adreno_get_param(struct msm_gpu *gpu, struct msm_file_private *ctx,
+int adreno_get_param(struct msm_gpu *gpu, struct msm_context *ctx,
                     uint32_t param, uint64_t *value, uint32_t *len)
 {
        struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
        }
 }
 
-int adreno_set_param(struct msm_gpu *gpu, struct msm_file_private *ctx,
+int adreno_set_param(struct msm_gpu *gpu, struct msm_context *ctx,
                     uint32_t param, uint64_t value, uint32_t len)
 {
        struct drm_device *drm = gpu->dev;
        case MSM_PARAM_SYSPROF:
                if (!capable(CAP_SYS_ADMIN))
                        return UERR(EPERM, drm, "invalid permissions");
-               return msm_file_private_set_sysprof(ctx, gpu, value);
+               return msm_context_set_sysprof(ctx, gpu, value);
        default:
                return UERR(EINVAL, drm, "%s: invalid param: %u", gpu->name, param);
        }
 
 /* Put vm_start above 32b to catch issues with not setting xyz_BASE_HI */
 #define ADRENO_VM_START 0x100000000ULL
 u64 adreno_private_address_space_size(struct msm_gpu *gpu);
-int adreno_get_param(struct msm_gpu *gpu, struct msm_file_private *ctx,
+int adreno_get_param(struct msm_gpu *gpu, struct msm_context *ctx,
                     uint32_t param, uint64_t *value, uint32_t *len);
-int adreno_set_param(struct msm_gpu *gpu, struct msm_file_private *ctx,
+int adreno_set_param(struct msm_gpu *gpu, struct msm_context *ctx,
                     uint32_t param, uint64_t value, uint32_t len);
 const struct firmware *adreno_request_fw(struct adreno_gpu *adreno_gpu,
                const char *fwname);
 
 {
        static atomic_t ident = ATOMIC_INIT(0);
        struct msm_drm_private *priv = dev->dev_private;
-       struct msm_file_private *ctx;
+       struct msm_context *ctx;
 
        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
        if (!ctx)
        return context_init(dev, file);
 }
 
-static void context_close(struct msm_file_private *ctx)
+static void context_close(struct msm_context *ctx)
 {
        msm_submitqueue_close(ctx);
-       msm_file_private_put(ctx);
+       msm_context_put(ctx);
 }
 
 static void msm_postclose(struct drm_device *dev, struct drm_file *file)
 {
        struct msm_drm_private *priv = dev->dev_private;
-       struct msm_file_private *ctx = file->driver_priv;
+       struct msm_context *ctx = file->driver_priv;
 
        /*
         * It is not possible to set sysprof param to non-zero if gpu
         * is not initialized:
         */
        if (priv->gpu)
-               msm_file_private_set_sysprof(ctx, priv->gpu, 0);
+               msm_context_set_sysprof(ctx, priv->gpu, 0);
 
        context_close(ctx);
 }
                uint64_t *iova)
 {
        struct msm_drm_private *priv = dev->dev_private;
-       struct msm_file_private *ctx = file->driver_priv;
+       struct msm_context *ctx = file->driver_priv;
 
        if (!priv->gpu)
                return -EINVAL;
                uint64_t iova)
 {
        struct msm_drm_private *priv = dev->dev_private;
-       struct msm_file_private *ctx = file->driver_priv;
+       struct msm_context *ctx = file->driver_priv;
 
        if (!priv->gpu)
                return -EINVAL;
 
 
 static void update_ctx_mem(struct drm_file *file, ssize_t size)
 {
-       struct msm_file_private *ctx = file->driver_priv;
+       struct msm_context *ctx = file->driver_priv;
        uint64_t ctx_mem = atomic64_add_return(size, &ctx->ctx_mem);
 
        rcu_read_lock(); /* Locks file->pid! */
 
 {
        struct msm_drm_private *priv = dev->dev_private;
        struct drm_msm_gem_submit *args = data;
-       struct msm_file_private *ctx = file->driver_priv;
+       struct msm_context *ctx = file->driver_priv;
        struct msm_gem_submit *submit = NULL;
        struct msm_gpu *gpu = priv->gpu;
        struct msm_gpu_submitqueue *queue;
 
        return 0;
 }
 
-void msm_gpu_show_fdinfo(struct msm_gpu *gpu, struct msm_file_private *ctx,
+void msm_gpu_show_fdinfo(struct msm_gpu *gpu, struct msm_context *ctx,
                         struct drm_printer *p)
 {
        drm_printf(p, "drm-engine-gpu:\t%llu ns\n", ctx->elapsed_ns);
 
 static void get_comm_cmdline(struct msm_gem_submit *submit, char **comm, char **cmd)
 {
-       struct msm_file_private *ctx = submit->queue->ctx;
+       struct msm_context *ctx = submit->queue->ctx;
        struct task_struct *task;
 
        WARN_ON(!mutex_is_locked(&submit->gpu->lock));
 
 struct msm_gem_submit;
 struct msm_gpu_perfcntr;
 struct msm_gpu_state;
-struct msm_file_private;
+struct msm_context;
 
 struct msm_gpu_config {
        const char *ioname;
  *    + z180_gpu
  */
 struct msm_gpu_funcs {
-       int (*get_param)(struct msm_gpu *gpu, struct msm_file_private *ctx,
+       int (*get_param)(struct msm_gpu *gpu, struct msm_context *ctx,
                         uint32_t param, uint64_t *value, uint32_t *len);
-       int (*set_param)(struct msm_gpu *gpu, struct msm_file_private *ctx,
+       int (*set_param)(struct msm_gpu *gpu, struct msm_context *ctx,
                         uint32_t param, uint64_t value, uint32_t len);
        int (*hw_init)(struct msm_gpu *gpu);
 
 #define NR_SCHED_PRIORITIES (1 + DRM_SCHED_PRIORITY_LOW - DRM_SCHED_PRIORITY_HIGH)
 
 /**
- * struct msm_file_private - per-drm_file context
+ * struct msm_context - per-drm_file context
  *
  * @queuelock:    synchronizes access to submitqueues list
  * @submitqueues: list of &msm_gpu_submitqueue created by userspace
  * @ref:          reference count
  * @seqno:        unique per process seqno
  */
-struct msm_file_private {
+struct msm_context {
        rwlock_t queuelock;
        struct list_head submitqueues;
        int queueid;
        u32 ring_nr;
        int faults;
        uint32_t last_fence;
-       struct msm_file_private *ctx;
+       struct msm_context *ctx;
        struct list_head node;
        struct idr fence_idr;
        struct spinlock idr_lock;
 int msm_gpu_pm_suspend(struct msm_gpu *gpu);
 int msm_gpu_pm_resume(struct msm_gpu *gpu);
 
-void msm_gpu_show_fdinfo(struct msm_gpu *gpu, struct msm_file_private *ctx,
+void msm_gpu_show_fdinfo(struct msm_gpu *gpu, struct msm_context *ctx,
                         struct drm_printer *p);
 
-int msm_submitqueue_init(struct drm_device *drm, struct msm_file_private *ctx);
-struct msm_gpu_submitqueue *msm_submitqueue_get(struct msm_file_private *ctx,
+int msm_submitqueue_init(struct drm_device *drm, struct msm_context *ctx);
+struct msm_gpu_submitqueue *msm_submitqueue_get(struct msm_context *ctx,
                u32 id);
 int msm_submitqueue_create(struct drm_device *drm,
-               struct msm_file_private *ctx,
+               struct msm_context *ctx,
                u32 prio, u32 flags, u32 *id);
-int msm_submitqueue_query(struct drm_device *drm, struct msm_file_private *ctx,
+int msm_submitqueue_query(struct drm_device *drm, struct msm_context *ctx,
                struct drm_msm_submitqueue_query *args);
-int msm_submitqueue_remove(struct msm_file_private *ctx, u32 id);
-void msm_submitqueue_close(struct msm_file_private *ctx);
+int msm_submitqueue_remove(struct msm_context *ctx, u32 id);
+void msm_submitqueue_close(struct msm_context *ctx);
 
 void msm_submitqueue_destroy(struct kref *kref);
 
-int msm_file_private_set_sysprof(struct msm_file_private *ctx,
-                                struct msm_gpu *gpu, int sysprof);
-void __msm_file_private_destroy(struct kref *kref);
+int msm_context_set_sysprof(struct msm_context *ctx, struct msm_gpu *gpu, int sysprof);
+void __msm_context_destroy(struct kref *kref);
 
-static inline void msm_file_private_put(struct msm_file_private *ctx)
+static inline void msm_context_put(struct msm_context *ctx)
 {
-       kref_put(&ctx->ref, __msm_file_private_destroy);
+       kref_put(&ctx->ref, __msm_context_destroy);
 }
 
-static inline struct msm_file_private *msm_file_private_get(
-       struct msm_file_private *ctx)
+static inline struct msm_context *msm_context_get(
+       struct msm_context *ctx)
 {
        kref_get(&ctx->ref);
        return ctx;
 
 
 #include "msm_gpu.h"
 
-int msm_file_private_set_sysprof(struct msm_file_private *ctx,
-                                struct msm_gpu *gpu, int sysprof)
+int msm_context_set_sysprof(struct msm_context *ctx, struct msm_gpu *gpu, int sysprof)
 {
        /*
         * Since pm_runtime and sysprof_active are both refcounts, we
        return 0;
 }
 
-void __msm_file_private_destroy(struct kref *kref)
+void __msm_context_destroy(struct kref *kref)
 {
-       struct msm_file_private *ctx = container_of(kref,
-               struct msm_file_private, ref);
+       struct msm_context *ctx = container_of(kref,
+               struct msm_context, ref);
        int i;
 
        for (i = 0; i < ARRAY_SIZE(ctx->entities); i++) {
 
        idr_destroy(&queue->fence_idr);
 
-       msm_file_private_put(queue->ctx);
+       msm_context_put(queue->ctx);
 
        kfree(queue);
 }
 
-struct msm_gpu_submitqueue *msm_submitqueue_get(struct msm_file_private *ctx,
+struct msm_gpu_submitqueue *msm_submitqueue_get(struct msm_context *ctx,
                u32 id)
 {
        struct msm_gpu_submitqueue *entry;
        return NULL;
 }
 
-void msm_submitqueue_close(struct msm_file_private *ctx)
+void msm_submitqueue_close(struct msm_context *ctx)
 {
        struct msm_gpu_submitqueue *entry, *tmp;
 
 }
 
 static struct drm_sched_entity *
-get_sched_entity(struct msm_file_private *ctx, struct msm_ringbuffer *ring,
+get_sched_entity(struct msm_context *ctx, struct msm_ringbuffer *ring,
                 unsigned ring_nr, enum drm_sched_priority sched_prio)
 {
        static DEFINE_MUTEX(entity_lock);
        return ctx->entities[idx];
 }
 
-int msm_submitqueue_create(struct drm_device *drm, struct msm_file_private *ctx,
+int msm_submitqueue_create(struct drm_device *drm, struct msm_context *ctx,
                u32 prio, u32 flags, u32 *id)
 {
        struct msm_drm_private *priv = drm->dev_private;
 
        write_lock(&ctx->queuelock);
 
-       queue->ctx = msm_file_private_get(ctx);
+       queue->ctx = msm_context_get(ctx);
        queue->id = ctx->queueid++;
 
        if (id)
  * Create the default submit-queue (id==0), used for backwards compatibility
  * for userspace that pre-dates the introduction of submitqueues.
  */
-int msm_submitqueue_init(struct drm_device *drm, struct msm_file_private *ctx)
+int msm_submitqueue_init(struct drm_device *drm, struct msm_context *ctx)
 {
        struct msm_drm_private *priv = drm->dev_private;
        int default_prio, max_priority;
        return ret ? -EFAULT : 0;
 }
 
-int msm_submitqueue_query(struct drm_device *drm, struct msm_file_private *ctx,
+int msm_submitqueue_query(struct drm_device *drm, struct msm_context *ctx,
                struct drm_msm_submitqueue_query *args)
 {
        struct msm_gpu_submitqueue *queue;
        return ret;
 }
 
-int msm_submitqueue_remove(struct msm_file_private *ctx, u32 id)
+int msm_submitqueue_remove(struct msm_context *ctx, u32 id)
 {
        struct msm_gpu_submitqueue *entry;