[PATCH v2 12/13] intel_gna: add a 'misc' device

From: Maciej Kwapulinski
Date: Wed Mar 24 2021 - 14:39:32 EST

The new 'misc' device is the node for applications in user space to
interact with the driver.

Signed-off-by: Maciej Kwapulinski <maciej.kwapulinski@xxxxxxxxxxxxxxx>
Tested-by: Savo Novakovic <savox.novakovic@xxxxxxxxx>
---
drivers/misc/intel/gna/gna_device.c | 69 ++++++++++++++++++++++++++--
drivers/misc/intel/gna/gna_device.h | 6 +++
drivers/misc/intel/gna/gna_driver.c | 2 +
drivers/misc/intel/gna/gna_driver.h | 2 +
drivers/misc/intel/gna/gna_hw.c | 28 +++++------
drivers/misc/intel/gna/gna_ioctl.c | 36 +++++++--------
drivers/misc/intel/gna/gna_mem.c | 32 ++++++-------
drivers/misc/intel/gna/gna_request.c | 32 ++++++-------
drivers/misc/intel/gna/gna_score.c | 28 +++++------
9 files changed, 154 insertions(+), 81 deletions(-)

diff --git a/drivers/misc/intel/gna/gna_device.c b/drivers/misc/intel/gna/gna_device.c
index d8e1d4b8a9eb..3f7f4c07d1a1 100644
--- a/drivers/misc/intel/gna/gna_device.c
+++ b/drivers/misc/intel/gna/gna_device.c
@@ -91,9 +91,57 @@ const struct pci_device_id gna_pci_ids[] = {

MODULE_DEVICE_TABLE(pci, gna_pci_ids);

+static int gna_open(struct inode *inode, struct file *f)
+{
+ return -EPERM;
+}
+
+static const struct file_operations gna_file_ops = {
+ .owner = THIS_MODULE,
+ .open = gna_open,
+};
+
+static void gna_dev_release(struct gna_private *gna_priv)
+{
+ misc_deregister(&gna_priv->misc);
+ kfree(gna_priv->misc.name);
+ gna_priv->misc.name = NULL;
+}
+
+static int gna_dev_create(struct gna_private *gna_priv, char *gna_name)
+{
+ struct pci_dev *pcidev;
+ int ret;
+
+ pcidev = gna_priv->pdev;
+
+ gna_priv->misc.minor = MISC_DYNAMIC_MINOR;
+ gna_priv->misc.name = kasprintf(GFP_KERNEL, "%s", gna_name);
+ gna_priv->misc.fops = &gna_file_ops;
+ gna_priv->misc.parent = &pcidev->dev;
+ gna_priv->misc.mode = 0666;
+
+ dev_dbg(&pcidev->dev, "registering device: %s\n",
+ gna_priv->misc.name);
+
+ ret = misc_register(&gna_priv->misc);
+ if (ret) {
+ dev_err(&pcidev->dev, "misc_register %s failed: %d\n",
+ gna_name, ret);
+ misc_deregister(&gna_priv->misc);
+ kfree(gna_priv->misc.name);
+ gna_priv->misc.name = NULL;
+ }
+
+ return ret;
+}
+
+
static int gna_dev_init(struct gna_private *gna_priv, struct pci_dev *pcidev,
const struct pci_device_id *pci_id)
{
+ // strlen(GNA_DV_NAME) + max minor number.
+ char gna_name[sizeof(GNA_DV_NAME) + sizeof("255") + 1];
u32 bld_reg;
int ret;

@@ -104,6 +152,8 @@ static int gna_dev_init(struct gna_private *gna_priv, struct pci_dev *pcidev,
gna_priv->info = *(struct gna_drv_info *)pci_id->driver_data;
gna_priv->drv_priv = &gna_drv_priv;

+ gna_priv->index = atomic_inc_return(&gna_priv->drv_priv->dev_last_idx);
+
bld_reg = gna_reg_read(gna_priv->bar0_base, GNA_MMIO_IBUFFS);
gna_priv->hw_info.in_buf_s = bld_reg & GENMASK(7, 0);

@@ -134,15 +184,26 @@ static int gna_dev_init(struct gna_private *gna_priv, struct pci_dev *pcidev,

init_waitqueue_head(&gna_priv->dev_busy_waitq);

- gna_priv->request_wq = create_singlethread_workqueue(GNA_DV_NAME);
+ snprintf(gna_name, sizeof(gna_name), "%s%d", GNA_DV_NAME, gna_priv->index);
+
+ gna_priv->request_wq = create_singlethread_workqueue(gna_name);
if (!gna_priv->request_wq) {
- dev_err(&pcidev->dev, "could not create %s workqueue\n", GNA_DV_NAME);
+ dev_err(&pcidev->dev, "could not create %s workqueue\n", gna_name);
ret = -EFAULT;
goto err_pci_drvdata_unset;
}

+ ret = gna_dev_create(gna_priv, gna_name);
+ if (ret) {
+ dev_err(&pcidev->dev, "could not create %s device\n", GNA_DV_NAME);
+ goto err_del_wq;
+ }
+
return 0;

+err_del_wq:
+ destroy_workqueue(gna_priv->request_wq);
+
err_pci_drvdata_unset:
pci_set_drvdata(pcidev, NULL);

@@ -151,6 +212,8 @@ static int gna_dev_init(struct gna_private *gna_priv, struct pci_dev *pcidev,

static void gna_dev_deinit(struct gna_private *gna_priv)
{
+ gna_dev_release(gna_priv);
+
flush_workqueue(gna_priv->request_wq);
destroy_workqueue(gna_priv->request_wq);

@@ -300,7 +363,7 @@ int gna_getparam(struct gna_private *gna_priv, union gna_parameter *param)
param->out.value = gna_device_type_by_hwid(gna_priv->info.hwid);
break;
default:
- dev_err(&gna_priv->pdev->dev, "unknown parameter id %llu\n", param->in.id);
+ dev_err(gna_priv->misc.this_device, "unknown parameter id %llu\n", param->in.id);
return -EINVAL;
}

diff --git a/drivers/misc/intel/gna/gna_device.h b/drivers/misc/intel/gna/gna_device.h
index aa7fadcf93b1..72692f5f3582 100644
--- a/drivers/misc/intel/gna/gna_device.h
+++ b/drivers/misc/intel/gna/gna_device.h
@@ -4,6 +4,7 @@
#ifndef __GNA_DEVICE_H__
#define __GNA_DEVICE_H__

+#include <linux/miscdevice.h>
#include <linux/types.h>
#include <linux/mutex.h>
#include <linux/list.h>
@@ -44,6 +45,11 @@ struct gna_private {
/* pdev->dev */
struct device *parent;

+ int index;
+
+ /* gna misc-device */
+ struct miscdevice misc;
+
int irq;
/* hardware status set by interrupt handler */
u32 hw_status;
diff --git a/drivers/misc/intel/gna/gna_driver.c b/drivers/misc/intel/gna/gna_driver.c
index a8f69a970f7a..79b735f3e492 100644
--- a/drivers/misc/intel/gna/gna_driver.c
+++ b/drivers/misc/intel/gna/gna_driver.c
@@ -23,6 +23,8 @@ static struct pci_driver gna_driver = {

static int __init gna_drv_init(void)
{
+ atomic_set(&gna_drv_priv.dev_last_idx, -1);
+
gna_drv_priv.recovery_timeout_jiffies = msecs_to_jiffies(recovery_timeout * 1000);

return pci_register_driver(&gna_driver);
diff --git a/drivers/misc/intel/gna/gna_driver.h b/drivers/misc/intel/gna/gna_driver.h
index 69087317d668..48a443d69f61 100644
--- a/drivers/misc/intel/gna/gna_driver.h
+++ b/drivers/misc/intel/gna/gna_driver.h
@@ -5,6 +5,7 @@
#define __GNA_DRIVER_H__

#include <linux/mutex.h>
+#include <linux/types.h>
#include <linux/list.h>

#define GNA_DV_NAME "intel_gna"
@@ -13,6 +14,7 @@ struct gna_private;
struct file;

struct gna_driver_private {
+ atomic_t dev_last_idx;
int recovery_timeout_jiffies;
};

diff --git a/drivers/misc/intel/gna/gna_hw.c b/drivers/misc/intel/gna/gna_hw.c
index 7d2f4ef00136..1f3f747aa88e 100644
--- a/drivers/misc/intel/gna/gna_hw.c
+++ b/drivers/misc/intel/gna/gna_hw.c
@@ -14,13 +14,13 @@ int gna_parse_hw_status(struct gna_private *gna_priv, u32 hw_status)
int status;

if (hw_status & GNA_ERROR) {
- dev_dbg(&gna_priv->pdev->dev, "GNA completed with errors: %#x\n", hw_status);
+ dev_dbg(gna_priv->misc.this_device, "GNA completed with errors: %#x\n", hw_status);
status = -EIO;
} else if (hw_status & GNA_STS_SCORE_COMPLETED) {
status = 0;
- dev_dbg(&gna_priv->pdev->dev, "GNA completed successfully: %#x\n", hw_status);
+ dev_dbg(gna_priv->misc.this_device, "GNA completed successfully: %#x\n", hw_status);
} else {
- dev_err(&gna_priv->pdev->dev, "GNA not completed, status: %#x\n", hw_status);
+ dev_err(gna_priv->misc.this_device, "GNA not completed, status: %#x\n", hw_status);
status = -ENODATA;
}

@@ -30,22 +30,22 @@ int gna_parse_hw_status(struct gna_private *gna_priv, u32 hw_status)
void gna_print_error_status(struct gna_private *gna_priv, u32 hw_status)
{
if (hw_status & GNA_STS_PARAM_OOR)
- dev_dbg(&gna_priv->pdev->dev, "GNA error: Param Out Range Error\n");
+ dev_dbg(gna_priv->misc.this_device, "GNA error: Param Out Range Error\n");

if (hw_status & GNA_STS_VA_OOR)
- dev_dbg(&gna_priv->pdev->dev, "GNA error: VA Out of Range Error\n");
+ dev_dbg(gna_priv->misc.this_device, "GNA error: VA Out of Range Error\n");

if (hw_status & GNA_STS_PCI_MMU_ERR)
- dev_dbg(&gna_priv->pdev->dev, "GNA error: PCI MMU Error\n");
+ dev_dbg(gna_priv->misc.this_device, "GNA error: PCI MMU Error\n");

if (hw_status & GNA_STS_PCI_DMA_ERR)
- dev_dbg(&gna_priv->pdev->dev, "GNA error: PCI MMU Error\n");
+ dev_dbg(gna_priv->misc.this_device, "GNA error: PCI MMU Error\n");

if (hw_status & GNA_STS_PCI_UNEXCOMPL_ERR)
- dev_dbg(&gna_priv->pdev->dev, "GNA error: PCI Unexpected Completion Error\n");
+ dev_dbg(gna_priv->misc.this_device, "GNA error: PCI Unexpected Completion Error\n");

if (hw_status & GNA_STS_SATURATE)
- dev_dbg(&gna_priv->pdev->dev, "GNA error: Saturation Reached !\n");
+ dev_dbg(gna_priv->misc.this_device, "GNA error: Saturation Reached !\n");
}

bool gna_hw_perf_enabled(struct gna_private *gna_priv)
@@ -77,7 +77,7 @@ void gna_start_scoring(struct gna_private *gna_priv, void __iomem *addr,

gna_reg_write(addr, GNA_MMIO_CTRL, ctrl);

- dev_dbg(&gna_priv->pdev->dev, "scoring started...\n");
+ dev_dbg(gna_priv->misc.this_device, "scoring started...\n");
}

static void gna_clear_saturation(struct gna_private *gna_priv)
@@ -87,8 +87,8 @@ static void gna_clear_saturation(struct gna_private *gna_priv)

val = gna_reg_read(addr, GNA_MMIO_STS);
if (val & GNA_STS_SATURATE) {
- dev_dbg(&gna_priv->pdev->dev, "saturation reached\n");
- dev_dbg(&gna_priv->pdev->dev, "status: %#x\n", val);
+ dev_dbg(gna_priv->misc.this_device, "saturation reached\n");
+ dev_dbg(gna_priv->misc.this_device, "status: %#x\n", val);

val = val & GNA_STS_SATURATE;
gna_reg_write(addr, GNA_MMIO_STS, val);
@@ -107,7 +107,7 @@ void gna_abort_hw(struct gna_private *gna_priv)
gna_clear_saturation(gna_priv);

val = gna_reg_read(addr, GNA_MMIO_STS);
- dev_dbg(&gna_priv->pdev->dev, "status before abort: %#x\n", val);
+ dev_dbg(gna_priv->misc.this_device, "status before abort: %#x\n", val);

val = gna_reg_read(addr, GNA_MMIO_CTRL);
val |= GNA_CTRL_ABORT_CLR_ACCEL;
@@ -121,5 +121,5 @@ void gna_abort_hw(struct gna_private *gna_priv)
} while (--i);

if (i == 0)
- dev_err(&gna_priv->pdev->dev, "abort did not complete\n");
+ dev_err(gna_priv->misc.this_device, "abort did not complete\n");
}
diff --git a/drivers/misc/intel/gna/gna_ioctl.c b/drivers/misc/intel/gna/gna_ioctl.c
index 79ce3aeb27cf..03d85850dcf1 100644
--- a/drivers/misc/intel/gna/gna_ioctl.c
+++ b/drivers/misc/intel/gna/gna_ioctl.c
@@ -22,25 +22,25 @@ static int gna_ioctl_score(struct gna_file_private *file_priv, void __user *argp
gna_priv = file_priv->gna_priv;

if (copy_from_user(&score_args, argptr, sizeof(score_args))) {
- dev_err(&gna_priv->pdev->dev, "could not copy score ioctl config from user\n");
+ dev_err(gna_priv->misc.this_device, "could not copy score ioctl config from user\n");
return -EFAULT;
}

ret = gna_validate_score_config(&score_args.in.config, file_priv);
if (ret) {
- dev_err(&gna_priv->pdev->dev, "request not valid\n");
+ dev_err(gna_priv->misc.this_device, "request not valid\n");
return ret;
}

ret = gna_enqueue_request(&score_args.in.config, file_priv, &request_id);
if (ret) {
- dev_err(&gna_priv->pdev->dev, "could not enqueue score request %d\n", ret);
+ dev_err(gna_priv->misc.this_device, "could not enqueue score request %d\n", ret);
return ret;
}

score_args.out.request_id = request_id;
if (copy_to_user(argptr, &score_args, sizeof(score_args))) {
- dev_err(&gna_priv->pdev->dev, "could not copy score ioctl status to user\n");
+ dev_err(gna_priv->misc.this_device, "could not copy score ioctl status to user\n");
return -EFAULT;
}

@@ -63,7 +63,7 @@ static int gna_ioctl_wait(struct file *f, void __user *argptr)
ret = 0;

if (copy_from_user(&wait_data, argptr, sizeof(wait_data))) {
- dev_err(&gna_priv->pdev->dev, "could not copy wait ioctl data from user\n");
+ dev_err(gna_priv->misc.this_device, "could not copy wait ioctl data from user\n");
return -EFAULT;
}

@@ -73,7 +73,7 @@ static int gna_ioctl_wait(struct file *f, void __user *argptr)
score_request = gna_find_request_by_id(request_id, gna_priv);

if (!score_request) {
- dev_err(&gna_priv->pdev->dev, "could not find request with id: %llu\n", request_id);
+ dev_err(gna_priv->misc.this_device, "could not find request with id: %llu\n", request_id);
return -EINVAL;
}

@@ -82,17 +82,17 @@ static int gna_ioctl_wait(struct file *f, void __user *argptr)
return -EINVAL;
}

- dev_dbg(&gna_priv->pdev->dev, "waiting for request %llu for timeout %u\n", request_id, timeout);
+ dev_dbg(gna_priv->misc.this_device, "waiting for request %llu for timeout %u\n", request_id, timeout);

ret = wait_event_interruptible_timeout(score_request->waitq, score_request->state == DONE,
msecs_to_jiffies(timeout));
if (ret == 0 || ret == -ERESTARTSYS) {
- dev_err(&gna_priv->pdev->dev, "request timed out, id: %llu\n", request_id);
+ dev_err(gna_priv->misc.this_device, "request timed out, id: %llu\n", request_id);
kref_put(&score_request->refcount, gna_request_release);
return -EBUSY;
}

- dev_dbg(&gna_priv->pdev->dev, "request wait completed with %d req id %llu\n", ret, request_id);
+ dev_dbg(gna_priv->misc.this_device, "request wait completed with %d req id %llu\n", ret, request_id);

wait_data.out.hw_perf = score_request->hw_perf;
wait_data.out.drv_perf = score_request->drv_perf;
@@ -100,14 +100,14 @@ static int gna_ioctl_wait(struct file *f, void __user *argptr)

ret = score_request->status;

- dev_dbg(&gna_priv->pdev->dev, "request status %d, hw status: %#x\n",
+ dev_dbg(gna_priv->misc.this_device, "request status %d, hw status: %#x\n",
score_request->status, score_request->hw_status);
kref_put(&score_request->refcount, gna_request_release);

gna_delete_request_by_id(request_id, gna_priv);

if (copy_to_user(argptr, &wait_data, sizeof(wait_data))) {
- dev_err(&gna_priv->pdev->dev, "could not copy wait ioctl status to user\n");
+ dev_err(gna_priv->misc.this_device, "could not copy wait ioctl status to user\n");
ret = -EFAULT;
}

@@ -123,7 +123,7 @@ static int gna_ioctl_map(struct gna_file_private *file_priv, void __user *argptr
gna_priv = file_priv->gna_priv;

if (copy_from_user(&gna_mem, argptr, sizeof(gna_mem))) {
- dev_err(&gna_priv->pdev->dev, "could not copy userptr ioctl data from user\n");
+ dev_err(gna_priv->misc.this_device, "could not copy userptr ioctl data from user\n");
return -EFAULT;
}

@@ -132,7 +132,7 @@ static int gna_ioctl_map(struct gna_file_private *file_priv, void __user *argptr
return ret;

if (copy_to_user(argptr, &gna_mem, sizeof(gna_mem))) {
- dev_err(&gna_priv->pdev->dev, "could not copy userptr ioctl status to user\n");
+ dev_err(gna_priv->misc.this_device, "could not copy userptr ioctl status to user\n");
return -EFAULT;
}

@@ -154,13 +154,13 @@ static int gna_ioctl_free(struct gna_file_private *file_priv, unsigned long arg)
mutex_unlock(&gna_priv->memidr_lock);

if (!mo) {
- dev_warn(&gna_priv->pdev->dev, "memory object not found\n");
+ dev_warn(gna_priv->misc.this_device, "memory object not found\n");
return -EINVAL;
}

queue_work(gna_priv->request_wq, &mo->work);
if (wait_event_interruptible(mo->waitq, true)) {
- dev_dbg(&gna_priv->pdev->dev, "wait interrupted\n");
+ dev_dbg(gna_priv->misc.this_device, "wait interrupted\n");
return -ETIME;
}

@@ -184,7 +184,7 @@ static int gna_ioctl_getparam(struct gna_private *gna_priv, void __user *argptr)
int ret;

if (copy_from_user(&param, argptr, sizeof(param))) {
- dev_err(&gna_priv->pdev->dev, "could not copy getparam ioctl data from user\n");
+ dev_err(gna_priv->misc.this_device, "could not copy getparam ioctl data from user\n");
return -EFAULT;
}

@@ -193,7 +193,7 @@ static int gna_ioctl_getparam(struct gna_private *gna_priv, void __user *argptr)
return ret;

if (copy_to_user(argptr, &param, sizeof(param))) {
- dev_err(&gna_priv->pdev->dev, "could not copy getparam ioctl status to user\n");
+ dev_err(gna_priv->misc.this_device, "could not copy getparam ioctl status to user\n");
return -EFAULT;
}

@@ -240,7 +240,7 @@ long gna_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
break;

default:
- dev_warn(&gna_priv->pdev->dev, "wrong ioctl %#x\n", cmd);
+ dev_warn(gna_priv->misc.this_device, "wrong ioctl %#x\n", cmd);
ret = -EINVAL;
break;
}
diff --git a/drivers/misc/intel/gna/gna_mem.c b/drivers/misc/intel/gna/gna_mem.c
index ce1691d68edb..d81dc8f7f2df 100644
--- a/drivers/misc/intel/gna/gna_mem.c
+++ b/drivers/misc/intel/gna/gna_mem.c
@@ -159,7 +159,7 @@ void gna_mmu_add(struct gna_private *gna_priv, struct gna_memory_object *mo)
j = mmu->filled_pages;
sgl = mo->sgt->sgl;
if (!sgl) {
- dev_warn(&gna_priv->pdev->dev, "empty scatter list in memory object\n");
+ dev_warn(gna_priv->misc.this_device, "empty scatter list in memory object\n");
goto warn_empty_sgl;
}
sg_page = sg_dma_address(sgl);
@@ -201,7 +201,7 @@ void gna_mmu_add(struct gna_private *gna_priv, struct gna_memory_object *mo)
mmu->hwdesc->mmu.vamaxaddr =
(mmu->filled_pts * PAGE_SIZE * GNA_PGDIR_ENTRIES) +
(mmu->filled_pages * PAGE_SIZE) - 1;
- dev_dbg(&gna_priv->pdev->dev, "vamaxaddr set to %u\n", mmu->hwdesc->mmu.vamaxaddr);
+ dev_dbg(gna_priv->misc.this_device, "vamaxaddr set to %u\n", mmu->hwdesc->mmu.vamaxaddr);

warn_empty_sgl:
mutex_unlock(&gna_priv->mmu_lock);
@@ -255,20 +255,20 @@ static int gna_get_pages(struct gna_memory_object *mo, u64 offset, u64 size)
gna_priv = mo->gna_priv;

if (mo->pages) {
- dev_warn(&gna_priv->pdev->dev, "pages are already pinned\n");
+ dev_warn(gna_priv->misc.this_device, "pages are already pinned\n");
return -EFAULT;
}

/* using vmalloc because num_pages can be large */
skip_size = round_down(offset, PAGE_SIZE);
effective_address = mo->user_address + skip_size;
- dev_dbg(&gna_priv->pdev->dev, "user address %llx\n", mo->user_address);
- dev_dbg(&gna_priv->pdev->dev, "effective user address %llx\n", effective_address);
+ dev_dbg(gna_priv->misc.this_device, "user address %llx\n", mo->user_address);
+ dev_dbg(gna_priv->misc.this_device, "effective user address %llx\n", effective_address);

effective_size = gna_buffer_get_size(offset, size);

num_pages = effective_size >> PAGE_SHIFT;
- dev_dbg(&gna_priv->pdev->dev, "allocating %d pages\n", num_pages);
+ dev_dbg(gna_priv->misc.this_device, "allocating %d pages\n", num_pages);
pages = kvmalloc_array(num_pages, sizeof(struct page *), GFP_KERNEL);
if (!pages) {
ret = -ENOMEM;
@@ -289,12 +289,12 @@ static int gna_get_pages(struct gna_memory_object *mo, u64 offset, u64 size)

if (num_pinned <= 0) {
ret = num_pinned;
- dev_err(&gna_priv->pdev->dev, "function get_user_pages_remote() failed\n");
+ dev_err(gna_priv->misc.this_device, "function get_user_pages_remote() failed\n");
goto err_free_pages;
}
if (num_pinned < num_pages) {
ret = -EFAULT;
- dev_err(&gna_priv->pdev->dev,
+ dev_err(gna_priv->misc.this_device,
"get_user_pages_remote() pinned fewer pages number than requested\n");
goto err_free_pages;
}
@@ -307,19 +307,19 @@ static int gna_get_pages(struct gna_memory_object *mo, u64 offset, u64 size)

ret = sg_alloc_table_from_pages(sgt, pages, num_pinned, 0, mo->memory_size, GFP_KERNEL);
if (ret) {
- dev_err(&gna_priv->pdev->dev, "could not alloc scatter list\n");
+ dev_err(gna_priv->misc.this_device, "could not alloc scatter list\n");
goto err_free_sgt;
}

if (IS_ERR(sgt->sgl)) {
- dev_err(&gna_priv->pdev->dev, "sgl allocation failed\n");
+ dev_err(gna_priv->misc.this_device, "sgl allocation failed\n");
ret = PTR_ERR(sgt->sgl);
goto err_free_sgt;
}

ents = pci_map_sg(gna_priv->pdev, sgt->sgl, sgt->nents, PCI_DMA_BIDIRECTIONAL);
if (ents <= 0) {
- dev_err(&gna_priv->pdev->dev, "could not map scatter gather list\n");
+ dev_err(gna_priv->misc.this_device, "could not map scatter gather list\n");
ret = -EIO;
goto err_free_sgl;
}
@@ -358,7 +358,7 @@ static void gna_put_pages(struct gna_memory_object *mo)
gna_priv = mo->gna_priv;

if (!mo->pages) {
- dev_warn(&gna_priv->pdev->dev, "memory object has no pages %llu\n", mo->memory_id);
+ dev_warn(gna_priv->misc.this_device, "memory object has no pages %llu\n", mo->memory_id);
return;
}

@@ -417,17 +417,17 @@ int gna_map_memory(struct gna_file_private *file_priv, union gna_memory_map *gna
gna_priv = file_priv->gna_priv;

if (gna_mem->in.address & ~PAGE_MASK) {
- dev_err(&gna_priv->pdev->dev, "user pointer not page aligned\n");
+ dev_err(gna_priv->misc.this_device, "user pointer not page aligned\n");
return -EINVAL;
}

if (!gna_mem->in.size) {
- dev_err(&gna_priv->pdev->dev, "invalid user memory size\n");
+ dev_err(gna_priv->misc.this_device, "invalid user memory size\n");
return -EINVAL;
}

if (!access_ok(u64_to_user_ptr(gna_mem->in.address), gna_mem->in.size)) {
- dev_err(&gna_priv->pdev->dev, "invalid user pointer\n");
+ dev_err(gna_priv->misc.this_device, "invalid user pointer\n");
return -EINVAL;
}

@@ -452,7 +452,7 @@ int gna_map_memory(struct gna_file_private *file_priv, union gna_memory_map *gna
mutex_unlock(&gna_priv->memidr_lock);

if (memory_id < 0) {
- dev_err(&gna_priv->pdev->dev, "idr allocation for memory failed\n");
+ dev_err(gna_priv->misc.this_device, "idr allocation for memory failed\n");
ret = -EFAULT;
goto err_free_mo;
}
diff --git a/drivers/misc/intel/gna/gna_request.c b/drivers/misc/intel/gna/gna_request.c
index ba9bac358270..f913a54bb1c3 100644
--- a/drivers/misc/intel/gna/gna_request.c
+++ b/drivers/misc/intel/gna/gna_request.c
@@ -39,7 +39,7 @@ static void gna_request_update_status(struct gna_request *score_request)
score_request->hw_perf.total = total_cycles;
score_request->hw_perf.stall = stall_cycles;
} else
- dev_warn(&gna_priv->pdev->dev, "GNA statistics missing\n");
+ dev_warn(gna_priv->misc.this_device, "GNA statistics missing\n");
}
if (unlikely(hw_status & GNA_ERROR))
gna_print_error_status(gna_priv, hw_status);
@@ -57,7 +57,7 @@ static void gna_request_process(struct work_struct *work)

score_request = container_of(work, struct gna_request, work);
gna_priv = score_request->gna_priv;
- dev_dbg(&gna_priv->pdev->dev, "processing request %llu\n", score_request->request_id);
+ dev_dbg(gna_priv->misc.this_device, "processing request %llu\n", score_request->request_id);

score_request->state = ACTIVE;

@@ -85,7 +85,7 @@ static void gna_request_process(struct work_struct *work)
!gna_priv->dev_busy, hw_timeout);

if (!hw_timeout)
- dev_warn(&gna_priv->pdev->dev, "hardware timeout occurred\n");
+ dev_warn(gna_priv->misc.this_device, "hardware timeout occurred\n");

gna_priv->hw_status = gna_reg_read(gna_priv->bar0_base, GNA_MMIO_STS);

@@ -102,7 +102,7 @@ static void gna_request_process(struct work_struct *work)
mo->ops->put_pages(mo);
mutex_unlock(&mo->page_lock);
} else {
- dev_warn(&gna_priv->pdev->dev, "mo not found %llu\n", buffer->memory_id);
+ dev_warn(gna_priv->misc.this_device, "mo not found %llu\n", buffer->memory_id);
}
}

@@ -115,7 +115,7 @@ static void gna_request_process(struct work_struct *work)

end:
score_request->drv_perf.completion = ktime_get_ns();
- dev_dbg(&gna_priv->pdev->dev, "request %llu done, waking processes\n",
+ dev_dbg(gna_priv->misc.this_device, "request %llu done, waking processes\n",
score_request->request_id);
score_request->state = DONE;
wake_up_interruptible_all(&score_request->waitq);
@@ -136,7 +136,7 @@ static struct gna_request *gna_request_create(struct gna_file_private *file_priv
return NULL;
kref_init(&score_request->refcount);

- dev_dbg(&gna_priv->pdev->dev, "layer_base %d layer_count %d\n",
+ dev_dbg(gna_priv->misc.this_device, "layer_base %d layer_count %d\n",
compute_cfg->layer_base, compute_cfg->layer_count);

score_request->request_id = atomic_inc_return(&gna_priv->request_count);
@@ -166,12 +166,12 @@ static int gna_validate_patches(struct gna_private *gna_priv, __u64 buffer_size,

for (idx = 0; idx < count; ++idx) {
if (patches[idx].size > 8) {
- dev_err(&gna_priv->pdev->dev, "invalid patch size: %llu\n", patches[idx].size);
+ dev_err(gna_priv->misc.this_device, "invalid patch size: %llu\n", patches[idx].size);
return -EINVAL;
}

if (!gna_validate_ranges(buffer_size, patches[idx].offset, patches[idx].size)) {
- dev_err(&gna_priv->pdev->dev,
+ dev_err(gna_priv->misc.this_device,
"patch out of bounds. buffer size: %llu, patch offset/size:%llu/%llu\n",
buffer_size, patches[idx].offset, patches[idx].size);
return -EINVAL;
@@ -204,14 +204,14 @@ static int gna_buffer_fill_patches(struct gna_buffer *buffer, struct gna_private

if (copy_from_user(patches, u64_to_user_ptr(patches_user),
sizeof(struct gna_memory_patch) * patch_count)) {
- dev_err(&gna_priv->pdev->dev, "copy %llu patches from user failed\n", patch_count);
+ dev_err(gna_priv->misc.this_device, "copy %llu patches from user failed\n", patch_count);
ret = -EFAULT;
goto err_fill_patches;
}

ret = gna_validate_patches(gna_priv, buffer->size, patches, patch_count);
if (ret) {
- dev_err(&gna_priv->pdev->dev, "patches failed validation\n");
+ dev_err(gna_priv->misc.this_device, "patches failed validation\n");
goto err_fill_patches;
}

@@ -246,7 +246,7 @@ static int gna_request_fill_buffers(struct gna_request *score_request,

if (copy_from_user(buffer_list, u64_to_user_ptr(compute_cfg->buffers_ptr),
sizeof(*buffer_list) * buffer_count)) {
- dev_err(&gna_priv->pdev->dev, "copying %llu buffers failed\n", buffer_count);
+ dev_err(gna_priv->misc.this_device, "copying %llu buffers failed\n", buffer_count);
ret = -EFAULT;
goto err_free_buffers;
}
@@ -257,7 +257,7 @@ static int gna_request_fill_buffers(struct gna_request *score_request,

for (j = 0; j < i; j++) {
if (buffer_list[j].memory_id == memory_id) {
- dev_err(&gna_priv->pdev->dev,
+ dev_err(gna_priv->misc.this_device,
"doubled memory id in score config. id:%llu\n", memory_id);
ret = -EINVAL;
goto err_zero_patch_ptr;
@@ -267,7 +267,7 @@ static int gna_request_fill_buffers(struct gna_request *score_request,
buffers_total_size +=
gna_buffer_get_size(buffer->offset, buffer->size);
if (buffers_total_size > gna_priv->info.max_hw_mem) {
- dev_err(&gna_priv->pdev->dev, "buffers' total size too big\n");
+ dev_err(gna_priv->misc.this_device, "buffers' total size too big\n");
ret = -EINVAL;
goto err_zero_patch_ptr;
}
@@ -276,14 +276,14 @@ static int gna_request_fill_buffers(struct gna_request *score_request,
mo = idr_find(&gna_priv->memory_idr, memory_id);
if (!mo) {
mutex_unlock(&gna_priv->memidr_lock);
- dev_err(&gna_priv->pdev->dev, "memory object %llu not found\n", memory_id);
+ dev_err(gna_priv->misc.this_device, "memory object %llu not found\n", memory_id);
ret = -EINVAL;
goto err_zero_patch_ptr;
}
mutex_unlock(&gna_priv->memidr_lock);

if (mo->fd != score_request->fd) {
- dev_err(&gna_priv->pdev->dev,
+ dev_err(gna_priv->misc.this_device,
"memory object from another file. %p != %p\n",
mo->fd, score_request->fd);
ret = -EINVAL;
@@ -291,7 +291,7 @@ static int gna_request_fill_buffers(struct gna_request *score_request,
}

if (!gna_validate_ranges(mo->memory_size, buffer->offset, buffer->size)) {
- dev_err(&gna_priv->pdev->dev,
+ dev_err(gna_priv->misc.this_device,
"buffer out of bounds. mo size: %llu, buffer offset/size:%llu/%llu\n",
mo->memory_size, buffer->offset, buffer->size);
ret = -EINVAL;
diff --git a/drivers/misc/intel/gna/gna_score.c b/drivers/misc/intel/gna/gna_score.c
index 794039d2da43..70ad867e215e 100644
--- a/drivers/misc/intel/gna/gna_score.c
+++ b/drivers/misc/intel/gna/gna_score.c
@@ -30,23 +30,23 @@ int gna_validate_score_config(struct gna_compute_cfg *compute_cfg,
gna_priv = file_priv->gna_priv;

if (compute_cfg->gna_mode > GNA_MODE_XNN) {
- dev_err(&gna_priv->pdev->dev, "invalid mode\n");
+ dev_err(gna_priv->misc.this_device, "invalid mode\n");
return -EINVAL;
}

if (compute_cfg->layer_count > gna_priv->info.max_layer_count) {
- dev_err(&gna_priv->pdev->dev, "max layer count exceeded\n");
+ dev_err(gna_priv->misc.this_device, "max layer count exceeded\n");
return -EINVAL;
}

if (compute_cfg->buffer_count == 0) {
- dev_err(&gna_priv->pdev->dev, "no buffers\n");
+ dev_err(gna_priv->misc.this_device, "no buffers\n");
return -EINVAL;
}

buffers_size = sizeof(struct gna_buffer) * compute_cfg->buffer_count;
if (!access_ok(u64_to_user_ptr(compute_cfg->buffers_ptr), buffers_size)) {
- dev_err(&gna_priv->pdev->dev, "invalid buffers pointer\n");
+ dev_err(gna_priv->misc.this_device, "invalid buffers pointer\n");
return -EINVAL;
}

@@ -63,7 +63,7 @@ static int gna_do_patch_memory(struct gna_private *gna_priv, struct gna_memory_o
value = patch->value;
size = patch->size;
dest = (u8 *)vaddr + patch->offset;
- dev_dbg(&gna_priv->pdev->dev, "patch offset: %llu, size: %zu, value: %llu\n",
+ dev_dbg(gna_priv->misc.this_device, "patch offset: %llu, size: %zu, value: %llu\n",
patch->offset, size, value);

switch (size) {
@@ -97,7 +97,7 @@ static int gna_mem_patch_memory(struct gna_private *gna_priv, struct gna_buffer
int ret = 0;
u32 i;

- dev_dbg(&gna_priv->pdev->dev, "memory_id: %llu, patch_count, %llu\n",
+ dev_dbg(gna_priv->misc.this_device, "memory_id: %llu, patch_count, %llu\n",
buffer->memory_id, buffer->patch_count);

mutex_lock(&gna_priv->memidr_lock);
@@ -179,7 +179,7 @@ static int gna_copy_gmm_config(struct gna_private *gna_priv,

buffer = gna_find_buffer(buffer_list, buffer_count, mmu_offset, &memory_offset);
if (!buffer) {
- dev_dbg(&gna_priv->pdev->dev, "buffer not found\n");
+ dev_dbg(gna_priv->misc.this_device, "buffer not found\n");
return -EINVAL;
}

@@ -187,13 +187,13 @@ static int gna_copy_gmm_config(struct gna_private *gna_priv,
mo = idr_find(&gna_priv->memory_idr, buffer->memory_id);
mutex_unlock(&gna_priv->memidr_lock);
if (!mo) {
- dev_dbg(&gna_priv->pdev->dev, "memory object not found\n");
+ dev_dbg(gna_priv->misc.this_device, "memory object not found\n");
return -EFAULT;
}

vaddr = vm_map_ram(mo->pages, mo->num_pinned, 0);
if (!vaddr) {
- dev_dbg(&gna_priv->pdev->dev, "mapping failed\n");
+ dev_dbg(gna_priv->misc.this_device, "mapping failed\n");
return -EFAULT;
}

@@ -230,9 +230,9 @@ int gna_score(struct gna_request *score_request)

buffer = score_request->buffer_list;
buffer_count = score_request->buffer_count;
- dev_dbg(&gna_priv->pdev->dev, "buffer count: %llu\n", buffer_count);
+ dev_dbg(gna_priv->misc.this_device, "buffer count: %llu\n", buffer_count);
for (i = 0; i < buffer_count; i++, buffer++) {
- dev_dbg(&gna_priv->pdev->dev, "patch count: %llu\n", buffer->patch_count);
+ dev_dbg(gna_priv->misc.this_device, "patch count: %llu\n", buffer->patch_count);
ret = gna_mem_patch_memory(gna_priv, buffer);
if (ret)
goto err_put_pages;
@@ -240,13 +240,13 @@ int gna_score(struct gna_request *score_request)

switch (compute_cfg->gna_mode) {
case GNA_MODE_XNN:
- dev_dbg(&gna_priv->pdev->dev, "xNN mode, labase: %d, lacount: %d\n",
+ dev_dbg(gna_priv->misc.this_device, "xNN mode, labase: %d, lacount: %d\n",
compute_cfg->layer_base, compute_cfg->layer_count);
xnn_config->labase = compute_cfg->layer_base;
xnn_config->lacount = compute_cfg->layer_count;
break;
case GNA_MODE_GMM:
- dev_dbg(&gna_priv->pdev->dev, "GMM mode, offset: %d\n", compute_cfg->layer_base);
+ dev_dbg(gna_priv->misc.this_device, "GMM mode, offset: %d\n", compute_cfg->layer_base);
ret = gna_copy_gmm_config(gna_priv, score_request->buffer_list,
buffer_count, compute_cfg->layer_base);
if (ret)
@@ -279,7 +279,7 @@ int gna_score(struct gna_request *score_request)
mutex_unlock(&mo->page_lock);
} else {
mo_valid = false;
- dev_warn(&gna_priv->pdev->dev, "memory object not found %llu\n",
+ dev_warn(gna_priv->misc.this_device, "memory object not found %llu\n",
buffer->memory_id);
}
buffer--;
--
2.28.0