From b7c60a63bd916ab6c0e779d9b7a8d10b4f98a9e0 Mon Sep 17 00:00:00 2001 From: Dorian Stoll Date: Mon, 28 Oct 2019 15:34:02 +0100 Subject: [PATCH] ipts: Cleanup ipts-i915 to pass checkpatch Signed-off-by: Dorian Stoll --- drivers/gpu/drm/i915_legacy/i915_debugfs.c | 22 +- drivers/gpu/drm/i915_legacy/i915_drv.c | 6 +- drivers/gpu/drm/i915_legacy/i915_irq.c | 4 +- drivers/gpu/drm/i915_legacy/intel_ipts.c | 433 ++++++++++----------- drivers/gpu/drm/i915_legacy/intel_ipts.h | 10 +- drivers/gpu/drm/i915_legacy/intel_panel.c | 4 +- 6 files changed, 239 insertions(+), 240 deletions(-) diff --git a/drivers/gpu/drm/i915_legacy/i915_debugfs.c b/drivers/gpu/drm/i915_legacy/i915_debugfs.c index 2ffad9712041..97606d249aea 100644 --- a/drivers/gpu/drm/i915_legacy/i915_debugfs.c +++ b/drivers/gpu/drm/i915_legacy/i915_debugfs.c @@ -39,9 +39,9 @@ #include "intel_guc_submission.h" #include "intel_hdcp.h" #include "intel_hdmi.h" +#include "intel_ipts.h" #include "intel_pm.h" #include "intel_psr.h" -#include "intel_ipts.h" static inline struct drm_i915_private *node_to_i915(struct drm_info_node *node) { @@ -4569,7 +4569,7 @@ static const struct file_operations i915_fifo_underrun_reset_ops = { }; static ssize_t -i915_intel_ipts_cleanup_write(struct file *filp, +i915_ipts_cleanup_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos) { @@ -4585,20 +4585,20 @@ i915_intel_ipts_cleanup_write(struct file *filp, if (!flag) return cnt; - intel_ipts_cleanup(dev); + ipts_cleanup(dev); return cnt; } -static const struct file_operations i915_intel_ipts_cleanup_ops = { +static const struct file_operations i915_ipts_cleanup_ops = { .owner = THIS_MODULE, .open = simple_open, - .write = i915_intel_ipts_cleanup_write, + .write = i915_ipts_cleanup_write, .llseek = default_llseek, }; static ssize_t -i915_intel_ipts_init_write(struct file *filp, +i915_ipts_init_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos) { @@ -4614,15 +4614,15 @@ i915_intel_ipts_init_write(struct file *filp, if (!flag) return cnt; - intel_ipts_init(dev); + ipts_init(dev); return cnt; } -static const struct file_operations i915_intel_ipts_init_ops = { +static const struct file_operations i915_ipts_init_ops = { .owner = THIS_MODULE, .open = simple_open, - .write = i915_intel_ipts_init_write, + .write = i915_ipts_init_write, .llseek = default_llseek, }; @@ -4702,8 +4702,8 @@ static const struct i915_debugfs_files { {"i915_ipc_status", &i915_ipc_status_fops}, {"i915_drrs_ctl", &i915_drrs_ctl_fops}, {"i915_edp_psr_debug", &i915_edp_psr_debug_fops}, - {"i915_intel_ipts_cleanup", &i915_intel_ipts_cleanup_ops}, - {"i915_intel_ipts_init", &i915_intel_ipts_init_ops}, + {"i915_ipts_cleanup", &i915_ipts_cleanup_ops}, + {"i915_ipts_init", &i915_ipts_init_ops}, }; int i915_debugfs_register(struct drm_i915_private *dev_priv) diff --git a/drivers/gpu/drm/i915_legacy/i915_drv.c b/drivers/gpu/drm/i915_legacy/i915_drv.c index adb7af18dc2b..9248887b7a23 100644 --- a/drivers/gpu/drm/i915_legacy/i915_drv.c +++ b/drivers/gpu/drm/i915_legacy/i915_drv.c @@ -59,11 +59,11 @@ #include "intel_dp.h" #include "intel_drv.h" #include "intel_fbdev.h" +#include "intel_ipts.h" #include "intel_pm.h" #include "intel_sprite.h" #include "intel_uc.h" #include "intel_workarounds.h" -#include "intel_ipts.h" static struct drm_driver driver; @@ -725,7 +725,7 @@ static int i915_load_modeset_init(struct drm_device *dev) intel_init_ipc(dev_priv); if (INTEL_GEN(dev_priv) >= 9 && i915_modparams.enable_guc && i915_modparams.enable_ipts) - intel_ipts_init(dev); + ipts_init(dev); return 0; @@ -1923,7 +1923,7 @@ void i915_driver_unload(struct drm_device *dev) disable_rpm_wakeref_asserts(dev_priv); if (INTEL_GEN(dev_priv) >= 9 && i915_modparams.enable_guc && i915_modparams.enable_ipts) - intel_ipts_cleanup(dev); + ipts_cleanup(dev); i915_driver_unregister(dev_priv); diff --git a/drivers/gpu/drm/i915_legacy/i915_irq.c b/drivers/gpu/drm/i915_legacy/i915_irq.c index 78fcd4b78480..4d20c509876a 100644 --- a/drivers/gpu/drm/i915_legacy/i915_irq.c +++ b/drivers/gpu/drm/i915_legacy/i915_irq.c @@ -40,8 +40,8 @@ #include "i915_drv.h" #include "i915_trace.h" #include "intel_drv.h" -#include "intel_psr.h" #include "intel_ipts.h" +#include "intel_psr.h" /** * DOC: interrupt handling @@ -1522,7 +1522,7 @@ gen8_cs_irq_handler(struct intel_engine_cs *engine, u32 iir) } if (iir & GT_RENDER_PIPECTL_NOTIFY_INTERRUPT && i915_modparams.enable_ipts) - intel_ipts_notify_complete(); + ipts_notify_complete(); if (tasklet) tasklet_hi_schedule(&engine->execlists.tasklet); diff --git a/drivers/gpu/drm/i915_legacy/intel_ipts.c b/drivers/gpu/drm/i915_legacy/intel_ipts.c index 593c4d6c5e1b..77147cfeb740 100644 --- a/drivers/gpu/drm/i915_legacy/intel_ipts.c +++ b/drivers/gpu/drm/i915_legacy/intel_ipts.c @@ -21,57 +21,59 @@ * IN THE SOFTWARE. * */ + +#include +#include #include -#include #include -#include -#include +#include #include "intel_guc_submission.h" #include "i915_drv.h" -#define SUPPORTED_IPTS_INTERFACE_VERSION 1 +#define SUPPORTED_IPTS_INTERFACE_VERSION 1 + +#define REACQUIRE_DB_THRESHOLD 10 -#define REACQUIRE_DB_THRESHOLD 10 -#define DB_LOST_CHECK_STEP1_INTERVAL 2500 /* ms */ -#define DB_LOST_CHECK_STEP2_INTERVAL 1000 /* ms */ +#define DB_LOST_CHECK_STEP1_INTERVAL 2500 // ms +#define DB_LOST_CHECK_STEP2_INTERVAL 1000 // ms -/* intel IPTS ctx for ipts support */ -typedef struct intel_ipts { +// CTX for ipts support +struct ipts { struct drm_device *dev; struct i915_gem_context *ipts_context; - intel_ipts_callback_t ipts_clbks; + struct ipts_callback ipts_clbks; - /* buffers' list */ + // buffers' list struct { - spinlock_t lock; + spinlock_t lock; struct list_head list; } buffers; void *data; struct delayed_work reacquire_db_work; - intel_ipts_wq_info_t wq_info; - u32 old_tail; - u32 old_head; - bool need_reacquire_db; + struct ipts_wq_info wq_info; + u32 old_tail; + u32 old_head; + bool need_reacquire_db; - bool connected; - bool initialized; -} intel_ipts_t; + bool connected; + bool initialized; +}; -intel_ipts_t intel_ipts; +struct ipts ipts; -typedef struct intel_ipts_object { +struct ipts_object { struct list_head list; struct drm_i915_gem_object *gem_obj; - void *cpu_addr; -} intel_ipts_object_t; + void *cpu_addr; +}; -static intel_ipts_object_t *ipts_object_create(size_t size, u32 flags) +static struct ipts_object *ipts_object_create(size_t size, u32 flags) { - struct drm_i915_private *dev_priv = to_i915(intel_ipts.dev); - intel_ipts_object_t *obj = NULL; + struct drm_i915_private *dev_priv = to_i915(ipts.dev); + struct ipts_object *obj = NULL; struct drm_i915_gem_object *gem_obj = NULL; int ret = 0; @@ -85,7 +87,7 @@ static intel_ipts_object_t *ipts_object_create(size_t size, u32 flags) goto err_out; } - /* Allocate the new object */ + // Allocate the new object gem_obj = i915_gem_object_create(dev_priv, size); if (gem_obj == NULL) { ret = -ENOMEM; @@ -102,45 +104,44 @@ static intel_ipts_object_t *ipts_object_create(size_t size, u32 flags) obj->gem_obj = gem_obj; - spin_lock(&intel_ipts.buffers.lock); - list_add_tail(&obj->list, &intel_ipts.buffers.list); - spin_unlock(&intel_ipts.buffers.lock); + spin_lock(&ipts.buffers.lock); + list_add_tail(&obj->list, &ipts.buffers.list); + spin_unlock(&ipts.buffers.lock); return obj; err_out: + if (gem_obj) i915_gem_free_object(&gem_obj->base); - if (obj) - kfree(obj); + kfree(obj); return NULL; } -static void ipts_object_free(intel_ipts_object_t* obj) +static void ipts_object_free(struct ipts_object *obj) { - spin_lock(&intel_ipts.buffers.lock); + spin_lock(&ipts.buffers.lock); list_del(&obj->list); - spin_unlock(&intel_ipts.buffers.lock); + spin_unlock(&ipts.buffers.lock); i915_gem_free_object(&obj->gem_obj->base); kfree(obj); } -static int ipts_object_pin(intel_ipts_object_t* obj, - struct i915_gem_context *ipts_ctx) +static int ipts_object_pin(struct ipts_object *obj, + struct i915_gem_context *ipts_ctx) { struct i915_address_space *vm = NULL; struct i915_vma *vma = NULL; - struct drm_i915_private *dev_priv = to_i915(intel_ipts.dev); + struct drm_i915_private *dev_priv = to_i915(ipts.dev); int ret = 0; - if (ipts_ctx->ppgtt) { + if (ipts_ctx->ppgtt) vm = &ipts_ctx->ppgtt->vm; - } else { + else vm = &dev_priv->ggtt.vm; - } vma = i915_vma_instance(obj->gem_obj, vm, NULL); if (IS_ERR(vma)) { @@ -153,18 +154,17 @@ static int ipts_object_pin(intel_ipts_object_t* obj, return ret; } -static void ipts_object_unpin(intel_ipts_object_t *obj) +static void ipts_object_unpin(struct ipts_object *obj) { - /* TBD: Add support */ + // TODO: Add support } -static void* ipts_object_map(intel_ipts_object_t *obj) +static void *ipts_object_map(struct ipts_object *obj) { - return i915_gem_object_pin_map(obj->gem_obj, I915_MAP_WB); } -static void ipts_object_unmap(intel_ipts_object_t* obj) +static void ipts_object_unmap(struct ipts_object *obj) { i915_gem_object_unpin_map(obj->gem_obj); obj->cpu_addr = NULL; @@ -173,18 +173,18 @@ static void ipts_object_unmap(intel_ipts_object_t* obj) static int create_ipts_context(void) { struct i915_gem_context *ipts_ctx = NULL; - struct drm_i915_private *dev_priv = to_i915(intel_ipts.dev); + struct drm_i915_private *dev_priv = to_i915(ipts.dev); struct intel_context *ce = NULL; int ret = 0; - /* Initialize the context right away.*/ - ret = i915_mutex_lock_interruptible(intel_ipts.dev); + // Initialize the context right away. + ret = i915_mutex_lock_interruptible(ipts.dev); if (ret) { - DRM_ERROR("i915_mutex_lock_interruptible failed \n"); + DRM_ERROR("i915_mutex_lock_interruptible failed\n"); return ret; } - ipts_ctx = i915_gem_context_create_ipts(intel_ipts.dev); + ipts_ctx = i915_gem_context_create_ipts(ipts.dev); if (IS_ERR(ipts_ctx)) { DRM_ERROR("Failed to create IPTS context (error %ld)\n", PTR_ERR(ipts_ctx)); @@ -202,23 +202,23 @@ static int create_ipts_context(void) ret = execlists_context_deferred_alloc(ce, ce->engine); if (ret) { - DRM_DEBUG("lr context allocation failed : %d\n", ret); + DRM_DEBUG("lr context allocation failed: %d\n", ret); goto err_ctx; } ret = execlists_context_pin(ce); if (ret) { - DRM_DEBUG("lr context pinning failed : %d\n", ret); + DRM_DEBUG("lr context pinning failed: %d\n", ret); goto err_ctx; } - /* Release the mutex */ - mutex_unlock(&intel_ipts.dev->struct_mutex); + // Release the mutex + mutex_unlock(&ipts.dev->struct_mutex); - spin_lock_init(&intel_ipts.buffers.lock); - INIT_LIST_HEAD(&intel_ipts.buffers.list); + spin_lock_init(&ipts.buffers.lock); + INIT_LIST_HEAD(&ipts.buffers.list); - intel_ipts.ipts_context = ipts_ctx; + ipts.ipts_context = ipts_ctx; return 0; @@ -227,7 +227,7 @@ static int create_ipts_context(void) i915_gem_context_put(ipts_ctx); err_unlock: - mutex_unlock(&intel_ipts.dev->struct_mutex); + mutex_unlock(&ipts.dev->struct_mutex); return ret; } @@ -235,18 +235,18 @@ static int create_ipts_context(void) static void destroy_ipts_context(void) { struct i915_gem_context *ipts_ctx = NULL; - struct drm_i915_private *dev_priv = to_i915(intel_ipts.dev); + struct drm_i915_private *dev_priv = to_i915(ipts.dev); struct intel_context *ce = NULL; int ret = 0; - ipts_ctx = intel_ipts.ipts_context; + ipts_ctx = ipts.ipts_context; ce = intel_context_lookup(ipts_ctx, dev_priv->engine[RCS0]); - /* Initialize the context right away.*/ - ret = i915_mutex_lock_interruptible(intel_ipts.dev); + // Initialize the context right away. + ret = i915_mutex_lock_interruptible(ipts.dev); if (ret) { - DRM_ERROR("i915_mutex_lock_interruptible failed \n"); + DRM_ERROR("i915_mutex_lock_interruptible failed\n"); return; } @@ -254,83 +254,79 @@ static void destroy_ipts_context(void) intel_context_unpin(ce); i915_gem_context_put(ipts_ctx); - mutex_unlock(&intel_ipts.dev->struct_mutex); + mutex_unlock(&ipts.dev->struct_mutex); } -int intel_ipts_notify_complete(void) +int ipts_notify_complete(void) { - if (intel_ipts.ipts_clbks.workload_complete) - intel_ipts.ipts_clbks.workload_complete(intel_ipts.data); + if (ipts.ipts_clbks.workload_complete) + ipts.ipts_clbks.workload_complete(ipts.data); return 0; } -int intel_ipts_notify_backlight_status(bool backlight_on) +int ipts_notify_backlight_status(bool backlight_on) { - if (intel_ipts.ipts_clbks.notify_gfx_status) { + if (ipts.ipts_clbks.notify_gfx_status) { if (backlight_on) { - intel_ipts.ipts_clbks.notify_gfx_status( - IPTS_NOTIFY_STA_BACKLIGHT_ON, - intel_ipts.data); - schedule_delayed_work(&intel_ipts.reacquire_db_work, + ipts.ipts_clbks.notify_gfx_status( + IPTS_NOTIFY_STA_BACKLIGHT_ON, ipts.data); + schedule_delayed_work(&ipts.reacquire_db_work, msecs_to_jiffies(DB_LOST_CHECK_STEP1_INTERVAL)); } else { - intel_ipts.ipts_clbks.notify_gfx_status( - IPTS_NOTIFY_STA_BACKLIGHT_OFF, - intel_ipts.data); - cancel_delayed_work(&intel_ipts.reacquire_db_work); + ipts.ipts_clbks.notify_gfx_status( + IPTS_NOTIFY_STA_BACKLIGHT_OFF, ipts.data); + cancel_delayed_work(&ipts.reacquire_db_work); } } return 0; } -static void intel_ipts_reacquire_db(intel_ipts_t *intel_ipts_p) +static void ipts_reacquire_db(struct ipts *ipts_p) { int ret = 0; - ret = i915_mutex_lock_interruptible(intel_ipts_p->dev); + ret = i915_mutex_lock_interruptible(ipts_p->dev); if (ret) { - DRM_ERROR("i915_mutex_lock_interruptible failed \n"); + DRM_ERROR("i915_mutex_lock_interruptible failed\n"); return; } - /* Reacquire the doorbell */ - i915_guc_ipts_reacquire_doorbell(intel_ipts_p->dev->dev_private); + // Reacquire the doorbell + i915_guc_ipts_reacquire_doorbell(ipts_p->dev->dev_private); - mutex_unlock(&intel_ipts_p->dev->struct_mutex); - - return; + mutex_unlock(&ipts_p->dev->struct_mutex); } -static int intel_ipts_get_wq_info(uint64_t gfx_handle, - intel_ipts_wq_info_t *wq_info) +static int ipts_get_wq_info(uint64_t gfx_handle, + struct ipts_wq_info *wq_info) { - if (gfx_handle != (uint64_t)&intel_ipts) { + if (gfx_handle != (uint64_t)&ipts) { DRM_ERROR("invalid gfx handle\n"); return -EINVAL; } - *wq_info = intel_ipts.wq_info; + *wq_info = ipts.wq_info; - intel_ipts_reacquire_db(&intel_ipts); - schedule_delayed_work(&intel_ipts.reacquire_db_work, - msecs_to_jiffies(DB_LOST_CHECK_STEP1_INTERVAL)); + ipts_reacquire_db(&ipts); + schedule_delayed_work(&ipts.reacquire_db_work, + msecs_to_jiffies(DB_LOST_CHECK_STEP1_INTERVAL)); return 0; } static int set_wq_info(void) { - struct drm_i915_private *dev_priv = to_i915(intel_ipts.dev); + struct drm_i915_private *dev_priv = to_i915(ipts.dev); struct intel_guc *guc = &dev_priv->guc; struct intel_guc_client *client; struct guc_process_desc *desc; + struct ipts_wq_info *wq_info; void *base = NULL; - intel_ipts_wq_info_t *wq_info; u64 phy_base = 0; - wq_info = &intel_ipts.wq_info; + wq_info = &ipts.wq_info; client = guc->ipts_client; if (!client) { @@ -339,50 +335,53 @@ static int set_wq_info(void) } base = client->vaddr; - desc = (struct guc_process_desc *)((u64)base + client->proc_desc_offset); + desc = (struct guc_process_desc *) + ((u64)base + client->proc_desc_offset); desc->wq_base_addr = (u64)base + GUC_DB_SIZE; desc->db_base_addr = (u64)base + client->doorbell_offset; - /* IPTS expects physical addresses to pass it to ME */ + // IPTS expects physical addresses to pass it to ME phy_base = sg_dma_address(client->vma->pages->sgl); wq_info->db_addr = desc->db_base_addr; - wq_info->db_phy_addr = phy_base + client->doorbell_offset; - wq_info->db_cookie_offset = offsetof(struct guc_doorbell_info, cookie); - wq_info->wq_addr = desc->wq_base_addr; - wq_info->wq_phy_addr = phy_base + GUC_DB_SIZE; - wq_info->wq_head_addr = (u64)&desc->head; - wq_info->wq_head_phy_addr = phy_base + client->proc_desc_offset + - offsetof(struct guc_process_desc, head); - wq_info->wq_tail_addr = (u64)&desc->tail; - wq_info->wq_tail_phy_addr = phy_base + client->proc_desc_offset + - offsetof(struct guc_process_desc, tail); - wq_info->wq_size = desc->wq_size_bytes; + wq_info->db_phy_addr = phy_base + client->doorbell_offset; + wq_info->db_cookie_offset = offsetof(struct guc_doorbell_info, cookie); + wq_info->wq_addr = desc->wq_base_addr; + wq_info->wq_phy_addr = phy_base + GUC_DB_SIZE; + wq_info->wq_head_addr = (u64)&desc->head; + wq_info->wq_tail_addr = (u64)&desc->tail; + wq_info->wq_size = desc->wq_size_bytes; + + wq_info->wq_head_phy_addr = phy_base + client->proc_desc_offset + + offsetof(struct guc_process_desc, head); + + wq_info->wq_tail_phy_addr = phy_base + client->proc_desc_offset + + offsetof(struct guc_process_desc, tail); return 0; } -static int intel_ipts_init_wq(void) +static int ipts_init_wq(void) { int ret = 0; - ret = i915_mutex_lock_interruptible(intel_ipts.dev); + ret = i915_mutex_lock_interruptible(ipts.dev); if (ret) { DRM_ERROR("i915_mutex_lock_interruptible failed\n"); return ret; } - /* disable IPTS submission */ - i915_guc_ipts_submission_disable(intel_ipts.dev->dev_private); + // disable IPTS submission + i915_guc_ipts_submission_disable(ipts.dev->dev_private); - /* enable IPTS submission */ - ret = i915_guc_ipts_submission_enable(intel_ipts.dev->dev_private, - intel_ipts.ipts_context); + // enable IPTS submission + ret = i915_guc_ipts_submission_enable(ipts.dev->dev_private, + ipts.ipts_context); if (ret) { - DRM_ERROR("i915_guc_ipts_submission_enable failed : %d\n", ret); + DRM_ERROR("i915_guc_ipts_submission_enable failed: %d\n", ret); goto out; - } + } ret = set_wq_info(); if (ret) { @@ -391,45 +390,45 @@ static int intel_ipts_init_wq(void) } out: - mutex_unlock(&intel_ipts.dev->struct_mutex); + mutex_unlock(&ipts.dev->struct_mutex); return ret; } -static void intel_ipts_release_wq(void) +static void ipts_release_wq(void) { int ret = 0; - ret = i915_mutex_lock_interruptible(intel_ipts.dev); + ret = i915_mutex_lock_interruptible(ipts.dev); if (ret) { DRM_ERROR("i915_mutex_lock_interruptible failed\n"); return; } - /* disable IPTS submission */ - i915_guc_ipts_submission_disable(intel_ipts.dev->dev_private); + // disable IPTS submission + i915_guc_ipts_submission_disable(ipts.dev->dev_private); - mutex_unlock(&intel_ipts.dev->struct_mutex); + mutex_unlock(&ipts.dev->struct_mutex); } -static int intel_ipts_map_buffer(u64 gfx_handle, intel_ipts_mapbuffer_t *mapbuf) +static int ipts_map_buffer(u64 gfx_handle, struct ipts_mapbuffer *mapbuf) { - intel_ipts_object_t* obj; + struct ipts_object *obj; struct i915_gem_context *ipts_ctx = NULL; - struct drm_i915_private *dev_priv = to_i915(intel_ipts.dev); + struct drm_i915_private *dev_priv = to_i915(ipts.dev); struct i915_address_space *vm = NULL; struct i915_vma *vma = NULL; int ret = 0; - if (gfx_handle != (uint64_t)&intel_ipts) { + if (gfx_handle != (uint64_t)&ipts) { DRM_ERROR("invalid gfx handle\n"); return -EINVAL; } - /* Acquire mutex first */ - ret = i915_mutex_lock_interruptible(intel_ipts.dev); + // Acquire mutex first + ret = i915_mutex_lock_interruptible(ipts.dev); if (ret) { - DRM_ERROR("i915_mutex_lock_interruptible failed \n"); + DRM_ERROR("i915_mutex_lock_interruptible failed\n"); return -EINVAL; } @@ -437,26 +436,24 @@ static int intel_ipts_map_buffer(u64 gfx_handle, intel_ipts_mapbuffer_t *mapbuf) if (!obj) return -ENOMEM; - ipts_ctx = intel_ipts.ipts_context; + ipts_ctx = ipts.ipts_context; ret = ipts_object_pin(obj, ipts_ctx); if (ret) { DRM_ERROR("Not able to pin iTouch obj\n"); ipts_object_free(obj); - mutex_unlock(&intel_ipts.dev->struct_mutex); + mutex_unlock(&ipts.dev->struct_mutex); return -ENOMEM; } - if (mapbuf->flags & IPTS_BUF_FLAG_CONTIGUOUS) { + if (mapbuf->flags & IPTS_BUF_FLAG_CONTIGUOUS) obj->cpu_addr = obj->gem_obj->phys_handle->vaddr; - } else { + else obj->cpu_addr = ipts_object_map(obj); - } - if (ipts_ctx->ppgtt) { + if (ipts_ctx->ppgtt) vm = &ipts_ctx->ppgtt->vm; - } else { + else vm = &dev_priv->ggtt.vm; - } vma = i915_vma_instance(obj->gem_obj, vm, NULL); if (IS_ERR(vma)) { @@ -464,42 +461,42 @@ static int intel_ipts_map_buffer(u64 gfx_handle, intel_ipts_mapbuffer_t *mapbuf) return -EINVAL; } - mapbuf->gfx_addr = (void*)vma->node.start; - mapbuf->cpu_addr = (void*)obj->cpu_addr; + mapbuf->gfx_addr = (void *)vma->node.start; + mapbuf->cpu_addr = (void *)obj->cpu_addr; mapbuf->buf_handle = (u64)obj; - if (mapbuf->flags & IPTS_BUF_FLAG_CONTIGUOUS) { + if (mapbuf->flags & IPTS_BUF_FLAG_CONTIGUOUS) mapbuf->phy_addr = (u64)obj->gem_obj->phys_handle->busaddr; - } - /* Release the mutex */ - mutex_unlock(&intel_ipts.dev->struct_mutex); + // Release the mutex + mutex_unlock(&ipts.dev->struct_mutex); return 0; } -static int intel_ipts_unmap_buffer(uint64_t gfx_handle, uint64_t buf_handle) +static int ipts_unmap_buffer(uint64_t gfx_handle, uint64_t buf_handle) { - intel_ipts_object_t* obj = (intel_ipts_object_t*)buf_handle; + struct ipts_object *obj = (struct ipts_object *)buf_handle; - if (gfx_handle != (uint64_t)&intel_ipts) { + if (gfx_handle != (uint64_t)&ipts) { DRM_ERROR("invalid gfx handle\n"); return -EINVAL; } if (!obj->gem_obj->phys_handle) ipts_object_unmap(obj); + ipts_object_unpin(obj); ipts_object_free(obj); return 0; } -int intel_ipts_connect(intel_ipts_connect_t *ipts_connect) +int ipts_connect(struct ipts_connect *ipts_connect) { u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_CONSUMER; - struct drm_i915_private *dev_priv = to_i915(intel_ipts.dev); + struct drm_i915_private *dev_priv = to_i915(ipts.dev); - if (!intel_ipts.initialized) + if (!ipts.initialized) return -EIO; if (!ipts_connect) @@ -508,59 +505,58 @@ int intel_ipts_connect(intel_ipts_connect_t *ipts_connect) if (ipts_connect->if_version > SUPPORTED_IPTS_INTERFACE_VERSION) return -EINVAL; - /* set up device-link for PM */ - if (!device_link_add(ipts_connect->client, intel_ipts.dev->dev, flags)) + // set up device-link for PM + if (!device_link_add(ipts_connect->client, ipts.dev->dev, flags)) return -EFAULT; - /* return gpu operations for ipts */ - ipts_connect->ipts_ops.get_wq_info = intel_ipts_get_wq_info; - ipts_connect->ipts_ops.map_buffer = intel_ipts_map_buffer; - ipts_connect->ipts_ops.unmap_buffer = intel_ipts_unmap_buffer; + // return gpu operations for ipts + ipts_connect->ipts_ops.get_wq_info = ipts_get_wq_info; + ipts_connect->ipts_ops.map_buffer = ipts_map_buffer; + ipts_connect->ipts_ops.unmap_buffer = ipts_unmap_buffer; ipts_connect->gfx_version = INTEL_INFO(dev_priv)->gen; - ipts_connect->gfx_handle = (uint64_t)&intel_ipts; + ipts_connect->gfx_handle = (uint64_t)&ipts; - /* save callback and data */ - intel_ipts.data = ipts_connect->data; - intel_ipts.ipts_clbks = ipts_connect->ipts_cb; + // save callback and data + ipts.data = ipts_connect->data; + ipts.ipts_clbks = ipts_connect->ipts_cb; - intel_ipts.connected = true; + ipts.connected = true; return 0; } -EXPORT_SYMBOL_GPL(intel_ipts_connect); +EXPORT_SYMBOL_GPL(ipts_connect); -void intel_ipts_disconnect(uint64_t gfx_handle) +void ipts_disconnect(uint64_t gfx_handle) { - if (!intel_ipts.initialized) + if (!ipts.initialized) return; - if (gfx_handle != (uint64_t)&intel_ipts || - intel_ipts.connected == false) { + if (gfx_handle != (uint64_t)&ipts || !ipts.connected) { DRM_ERROR("invalid gfx handle\n"); return; } - intel_ipts.data = 0; - memset(&intel_ipts.ipts_clbks, 0, sizeof(intel_ipts_callback_t)); + ipts.data = 0; + memset(&ipts.ipts_clbks, 0, sizeof(struct ipts_callback)); - intel_ipts.connected = false; + ipts.connected = false; } -EXPORT_SYMBOL_GPL(intel_ipts_disconnect); +EXPORT_SYMBOL_GPL(ipts_disconnect); static void reacquire_db_work_func(struct work_struct *work) { - struct delayed_work *d_work = container_of(work, struct delayed_work, - work); - intel_ipts_t *intel_ipts_p = container_of(d_work, intel_ipts_t, - reacquire_db_work); + struct delayed_work *d_work = container_of(work, + struct delayed_work, work); + struct ipts *ipts_p = container_of(d_work, + struct ipts, reacquire_db_work); u32 head; u32 tail; u32 size; u32 load; - head = *(u32*)intel_ipts_p->wq_info.wq_head_addr; - tail = *(u32*)intel_ipts_p->wq_info.wq_tail_addr; - size = intel_ipts_p->wq_info.wq_size; + head = *(u32 *)ipts_p->wq_info.wq_head_addr; + tail = *(u32 *)ipts_p->wq_info.wq_tail_addr; + size = ipts_p->wq_info.wq_size; if (head >= tail) load = head - tail; @@ -568,84 +564,87 @@ static void reacquire_db_work_func(struct work_struct *work) load = head + size - tail; if (load < REACQUIRE_DB_THRESHOLD) { - intel_ipts_p->need_reacquire_db = false; + ipts_p->need_reacquire_db = false; goto reschedule_work; } - if (intel_ipts_p->need_reacquire_db) { - if (intel_ipts_p->old_head == head && intel_ipts_p->old_tail == tail) - intel_ipts_reacquire_db(intel_ipts_p); - intel_ipts_p->need_reacquire_db = false; + if (ipts_p->need_reacquire_db) { + if (ipts_p->old_head == head && + ipts_p->old_tail == tail) + ipts_reacquire_db(ipts_p); + ipts_p->need_reacquire_db = false; } else { - intel_ipts_p->old_head = head; - intel_ipts_p->old_tail = tail; - intel_ipts_p->need_reacquire_db = true; + ipts_p->old_head = head; + ipts_p->old_tail = tail; + ipts_p->need_reacquire_db = true; - /* recheck */ - schedule_delayed_work(&intel_ipts_p->reacquire_db_work, - msecs_to_jiffies(DB_LOST_CHECK_STEP2_INTERVAL)); + // recheck + schedule_delayed_work(&ipts_p->reacquire_db_work, + msecs_to_jiffies(DB_LOST_CHECK_STEP2_INTERVAL)); return; } reschedule_work: - schedule_delayed_work(&intel_ipts_p->reacquire_db_work, - msecs_to_jiffies(DB_LOST_CHECK_STEP1_INTERVAL)); + schedule_delayed_work(&ipts_p->reacquire_db_work, + msecs_to_jiffies(DB_LOST_CHECK_STEP1_INTERVAL)); } /** - * intel_ipts_init - Initialize ipts support + * ipts_init - Initialize ipts support * @dev: drm device * * Setup the required structures for ipts. */ -int intel_ipts_init(struct drm_device *dev) +int ipts_init(struct drm_device *dev) { int ret = 0; pr_info("ipts: initializing ipts\n"); - intel_ipts.dev = dev; - INIT_DELAYED_WORK(&intel_ipts.reacquire_db_work, reacquire_db_work_func); + ipts.dev = dev; + INIT_DELAYED_WORK(&ipts.reacquire_db_work, + reacquire_db_work_func); ret = create_ipts_context(); if (ret) return -ENOMEM; - ret = intel_ipts_init_wq(); + ret = ipts_init_wq(); if (ret) return ret; - intel_ipts.initialized = true; + ipts.initialized = true; pr_info("ipts: Intel iTouch framework initialized\n"); return ret; } -void intel_ipts_cleanup(struct drm_device *dev) +void ipts_cleanup(struct drm_device *dev) { - intel_ipts_object_t *obj, *n; + struct ipts_object *obj, *n; - if (intel_ipts.dev == dev) { - list_for_each_entry_safe(obj, n, &intel_ipts.buffers.list, list) { - struct i915_vma *vma, *vn; - - list_for_each_entry_safe(vma, vn, - &obj->list, obj_link) { - vma->flags &= ~I915_VMA_PIN_MASK; - i915_vma_destroy(vma); - } + if (ipts.dev != dev) + return; - list_del(&obj->list); + list_for_each_entry_safe(obj, n, &ipts.buffers.list, list) { + struct i915_vma *vma, *vn; - if (!obj->gem_obj->phys_handle) - ipts_object_unmap(obj); - ipts_object_unpin(obj); - i915_gem_free_object(&obj->gem_obj->base); - kfree(obj); + list_for_each_entry_safe(vma, vn, &obj->list, obj_link) { + vma->flags &= ~I915_VMA_PIN_MASK; + i915_vma_destroy(vma); } - intel_ipts_release_wq(); - destroy_ipts_context(); - cancel_delayed_work(&intel_ipts.reacquire_db_work); + list_del(&obj->list); + + if (!obj->gem_obj->phys_handle) + ipts_object_unmap(obj); + + ipts_object_unpin(obj); + i915_gem_free_object(&obj->gem_obj->base); + kfree(obj); } + + ipts_release_wq(); + destroy_ipts_context(); + cancel_delayed_work(&ipts.reacquire_db_work); } diff --git a/drivers/gpu/drm/i915_legacy/intel_ipts.h b/drivers/gpu/drm/i915_legacy/intel_ipts.h index a6965d102417..67f90b72f237 100644 --- a/drivers/gpu/drm/i915_legacy/intel_ipts.h +++ b/drivers/gpu/drm/i915_legacy/intel_ipts.h @@ -24,11 +24,11 @@ #ifndef _INTEL_IPTS_H_ #define _INTEL_IPTS_H_ -struct drm_device; +#include -int intel_ipts_init(struct drm_device *dev); -void intel_ipts_cleanup(struct drm_device *dev); -int intel_ipts_notify_backlight_status(bool backlight_on); -int intel_ipts_notify_complete(void); +int ipts_init(struct drm_device *dev); +void ipts_cleanup(struct drm_device *dev); +int ipts_notify_backlight_status(bool backlight_on); +int ipts_notify_complete(void); #endif //_INTEL_IPTS_H_ diff --git a/drivers/gpu/drm/i915_legacy/intel_panel.c b/drivers/gpu/drm/i915_legacy/intel_panel.c index 2d3c523ba5c7..f191292388ef 100644 --- a/drivers/gpu/drm/i915_legacy/intel_panel.c +++ b/drivers/gpu/drm/i915_legacy/intel_panel.c @@ -732,7 +732,7 @@ static void lpt_disable_backlight(const struct drm_connector_state *old_conn_sta u32 tmp; if (INTEL_GEN(dev_priv) >= 9 && i915_modparams.enable_guc && i915_modparams.enable_ipts) - intel_ipts_notify_backlight_status(false); + ipts_notify_backlight_status(false); intel_panel_actually_set_backlight(old_conn_state, 0); @@ -923,7 +923,7 @@ static void lpt_enable_backlight(const struct intel_crtc_state *crtc_state, intel_panel_actually_set_backlight(conn_state, panel->backlight.level); if (INTEL_GEN(dev_priv) >= 9 && i915_modparams.enable_guc && i915_modparams.enable_ipts) - intel_ipts_notify_backlight_status(true); + ipts_notify_backlight_status(true); } static void pch_enable_backlight(const struct intel_crtc_state *crtc_state,