Add the VM-side access-window component for Mali v15 GPUs. Negotiate the AM message version, request GPU access from the arbiter, and wait for the window-open interrupt. Yield GPU access during suspend.
Keep hardware binding in panthor_hw_init(). Call panthor_hw_info_init() to read GPU information after panthor_aw_init() obtains GPU access. Signed-off-by: Karunika Choo <[email protected]> --- v2: - Introduce spinlock to protect and serialize state acquisition and updates. - Make panthor_aw_request recheck states after wait to handle unexpected state transitions and prevent timing out waiting on an invalid state. - Tighten protocol version checks and reject sending GPU_REQUEST to incompatible arbiter. - Handle lost GPU_REQUEST message if arbiter was restarted - Add WINDOW_CLOSED and WINDOW_OPENED handling. - Fix indentation for IRQ_NONE return in the IRQ raw handler. - clean up IRQ state during failed initialization and termination. - Handle yielding of the GPU during termination. - Split GPU_STOPPED state into YIELDING and SUSPEND_PENDING. Removed old GPU_STOP state as we no longer support the ARB_VM_GPU_STOP message. v1: - Adapt AW IRQ handling to the updated IRQ locking/state interfaces and reuse panthor_irq_suspend(). - Handle -ENOSPC from AM message sending when the outgoing FIFO is full. drivers/gpu/drm/panthor/Makefile | 1 + drivers/gpu/drm/panthor/panthor_aw.c | 498 +++++++++++++++++++++++ drivers/gpu/drm/panthor/panthor_aw.h | 42 ++ drivers/gpu/drm/panthor/panthor_device.c | 15 +- drivers/gpu/drm/panthor/panthor_device.h | 4 + drivers/gpu/drm/panthor/panthor_hw.c | 8 +- drivers/gpu/drm/panthor/panthor_hw.h | 2 + 7 files changed, 563 insertions(+), 7 deletions(-) create mode 100644 drivers/gpu/drm/panthor/panthor_aw.c create mode 100644 drivers/gpu/drm/panthor/panthor_aw.h diff --git a/drivers/gpu/drm/panthor/Makefile b/drivers/gpu/drm/panthor/Makefile index 5d4d0ae64952e..aa48212653dc3 100644 --- a/drivers/gpu/drm/panthor/Makefile +++ b/drivers/gpu/drm/panthor/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 or MIT panthor-y := \ + panthor_aw.o \ panthor_devfreq.o \ panthor_device.o \ panthor_drv.o \ diff --git a/drivers/gpu/drm/panthor/panthor_aw.c b/drivers/gpu/drm/panthor/panthor_aw.c new file mode 100644 index 0000000000000..5ab1d44f0a22e --- /dev/null +++ b/drivers/gpu/drm/panthor/panthor_aw.c @@ -0,0 +1,498 @@ +// SPDX-License-Identifier: GPL-2.0 or MIT +/* Copyright 2026 ARM Limited. All rights reserved. */ + +#include <linux/platform_device.h> +#include <linux/spinlock.h> + +#include <drm/drm_managed.h> +#include <drm/drm_print.h> +#include <drm/drm_drv.h> + +#include "panthor_am_msg.h" +#include "panthor_aw.h" +#include "panthor_device.h" +#include "panthor_fw.h" +#include "panthor_hw.h" +#include "panthor_sched.h" + +#include "panthor_trace.h" + +#define WINDOW_CONTROL_BASE 0x0 +#define WINDOW_CONTROL_SIZE 0x1000 + +#define WINDOW_STATUS 0x43c +#define WINDOW_STATUS_IRQ_WINDOW_CONTROL BIT(0) +#define WINDOW_STATUS_IRQ_GPU_CONTROL BIT(1) +#define WINDOW_STATUS_IRQ_GPU_POWER BIT(2) +#define WINDOW_STATUS_IRQ_JOB_CONTROL BIT(3) +#define WINDOW_STATUS_IRQ_MMU_CONTROL BIT(4) +#define WINDOW_STATUS_WINDOW_OPEN BIT(31) + +#define WINDOW_INT_BASE 0x440 +#define WINDOW_IRQ_MESSAGE BIT(0) +#define WINDOW_IRQ_INVALID_ACCESS BIT(1) +#define WINDOW_IRQ_WINDOW_OPENING BIT(2) +#define WINDOW_IRQ_WINDOW_OPENED BIT(3) +#define WINDOW_IRQ_WINDOW_CLOSED BIT(4) + +#define WINDOW_MESSAGE_BASE 0x460 + +#define WINDOW_IRQ_MASK \ + (WINDOW_IRQ_MESSAGE | WINDOW_IRQ_WINDOW_OPENED | WINDOW_IRQ_WINDOW_CLOSED) + +#define PANTHOR_AW_HANDSHAKE_TIMEOUT_MS (5 * MSEC_PER_SEC) +#define PANTHOR_AW_GPU_REQUEST_TIMEOUT_MS (5 * MSEC_PER_SEC) +#define PANTHOR_AW_STATE_TRANSITION_TIMEOUT_MS (5 * MSEC_PER_SEC) + +#define panthor_aw_wait_cond(_aw, _cond, _timeout_ms) \ +({ \ + int __ret = 0; \ + if (!wait_event_timeout((_aw)->waitqueue, _cond, \ + msecs_to_jiffies(_timeout_ms))) \ + if (!(_cond)) \ + __ret = -ETIMEDOUT; \ + __ret; \ +}) + +struct panthor_aw { + /** @ptdev: Pointer to Panthor device */ + struct panthor_device *ptdev; + + /** @iomem: CPU mapping of WINDOW_CONTROL iomem region */ + void __iomem *iomem; + + /** @irq: IRQ data */ + struct panthor_irq irq; + + /** @msg: Messaging data */ + struct panthor_am_msg msg; + + /** @waitqueue: Event wait queue. Not IRQ safe */ + wait_queue_head_t waitqueue; + + /** @lock: Protects @state */ + spinlock_t lock; + + /** @state: Current state of the AW */ + atomic_t state; + + /** @wq: Scheduler workqueue to dispatch events */ + struct workqueue_struct *wq; + + /** @msg_retry_work: Work to resend messages */ + struct work_struct msg_retry_work; +}; + +static bool panthor_aw_is_open(struct panthor_aw *aw) +{ + return gpu_read(aw->iomem, WINDOW_STATUS) & WINDOW_STATUS_WINDOW_OPEN; +} + +static void panthor_aw_state_set(struct panthor_aw *aw, enum panthor_aw_state new) +{ + atomic_set(&aw->state, new); + + wake_up_all(&aw->waitqueue); +} + +static bool panthor_aw_state_try_set(struct panthor_aw *aw, + enum panthor_aw_state expected, + enum panthor_aw_state new) +{ + int old_state = atomic_cmpxchg(&aw->state, expected, new); + bool res = (old_state == expected); + + if (res) + wake_up_all(&aw->waitqueue); + + return res; +} + +static int panthor_aw_state_wait(struct panthor_aw *aw, + enum panthor_aw_state target, u32 timeout_ms) +{ + return panthor_aw_wait_cond(aw, atomic_read(&aw->state) == target, timeout_ms); +} + +static void panthor_aw_msg_retry_work(struct work_struct *work) +{ + struct panthor_aw *aw = + container_of(work, struct panthor_aw, msg_retry_work); + struct panthor_am_msg *msg = &aw->msg; + int ret; + + ret = panthor_am_msg_retry(msg); + if (ret == -EINVAL) + drm_warn(&aw->ptdev->base, "Send FIFO unexpectedly empty"); + + if (ret == -EBUSY || ret == -EAGAIN) + queue_work(aw->wq, &aw->msg_retry_work); +} + +static void panthor_aw_send_msg(struct panthor_aw *aw, u64 message) +{ + struct panthor_device *ptdev = aw->ptdev; + int ret; + + ret = panthor_am_msg_send(&aw->msg, message); + if (ret == -ENOSPC) + drm_err(&ptdev->base, "Send FIFO is full"); + + if (ret == -EBUSY) { + drm_dbg(&ptdev->base, "Pending messages, scheduling retry work"); + queue_work(aw->wq, &aw->msg_retry_work); + } +} + +static void panthor_aw_handshake_handle(struct panthor_aw *aw, u64 message) +{ + struct panthor_device *ptdev = aw->ptdev; + bool acked = AM_MSG_ACK_GET(message); + u8 version = AM_MSG_VERSION_GET(message); + u8 reply_version = AM_MSG_CURRENT_VERSION; + int ret; + + ret = panthor_am_msg_version_validate(&aw->msg, version, acked, + &reply_version); + if (ret == -EOPNOTSUPP) + drm_warn(&ptdev->base, + "Msg protocol version less than minimum supported (%u < %u)", + version, AM_MSG_MIN_SUPPORTED_VERSION); + + if (!acked) { + u64 reply = VM_ARB_INIT_MAKE(1, reply_version); + + panthor_aw_send_msg(aw, reply); + + guard(spinlock_irqsave)(&aw->lock); + + /* + * If state is GPU_REQUEST, arbiter previously completed + * handshake, New INIT could mean that the arbiter was restarted + * and we need to resend GPU_REQUEST. + */ + if (atomic_read(&aw->state) == PANTHOR_AW_STATE_GPU_REQUEST) { + panthor_aw_send_msg(aw, VM_ARB_GPU_REQUEST); + return; + } + } + + scoped_guard(spinlock_irqsave, &aw->lock) + panthor_aw_state_try_set(aw, PANTHOR_AW_STATE_INIT, + PANTHOR_AW_STATE_READY); +} + +static void panthor_aw_handshake_init(struct panthor_aw *aw) +{ + u64 message = VM_ARB_INIT_MAKE(0, AM_MSG_CURRENT_VERSION); + + panthor_aw_send_msg(aw, message); +} + +static void panthor_aw_handle_message(struct panthor_aw *aw) +{ + struct panthor_device *ptdev = aw->ptdev; + const u64 message = panthor_am_msg_read(&aw->msg); + const u8 msg_id = AM_MSG_ID_GET(message); + + /* currently only support ARB_VM_INIT */ + if (msg_id == ARB_VM_INIT) + panthor_aw_handshake_handle(aw, message); + else + drm_warn(&ptdev->base, "Unsupported msg id (0x%x)", msg_id); +} + +static void panthor_aw_handle_window_closed(struct panthor_aw *aw) +{ + struct panthor_device *ptdev = aw->ptdev; + + guard(spinlock_irqsave)(&aw->lock); + + if (panthor_aw_is_open(aw)) + return; + + switch (atomic_read(&aw->state)) { + case PANTHOR_AW_STATE_GPU_GRANTED: + /* TODO: schedule cleanup */ + break; + case PANTHOR_AW_STATE_GPU_REQUEST: + /* + * Window may have been closed immediately after opening. + * Setting state back to READY will prevent WINDOW_OPENED from + * mistakenly transitioning the state to GRANTED. + */ + case PANTHOR_AW_STATE_YIELDING: + /* Triggered from messaged-based yield. Unblock its wait */ + panthor_aw_state_set(aw, PANTHOR_AW_STATE_READY); + break; + default: + drm_warn(&ptdev->base, "Unexpected WINDOW_CLOSED received"); + break; + } +} + +static void panthor_aw_handle_window_opened(struct panthor_aw *aw) +{ + guard(spinlock_irqsave)(&aw->lock); + + if (!panthor_aw_is_open(aw)) + return; + + switch (atomic_read(&aw->state)) { + case PANTHOR_AW_STATE_GPU_GRANTED: + case PANTHOR_AW_STATE_SUSPEND_PENDING: + case PANTHOR_AW_STATE_INIT: + break; + case PANTHOR_AW_STATE_GPU_REQUEST: + panthor_aw_state_set(aw, PANTHOR_AW_STATE_GPU_GRANTED); + break; + default: + panthor_aw_state_set(aw, PANTHOR_AW_STATE_YIELDING); + panthor_aw_send_msg(aw, VM_ARB_GPU_STOPPED); + } +} + +static irqreturn_t panthor_aw_irq_raw_hander(int irq, void *data) +{ + struct panthor_irq *pirq = data; + struct panthor_device *ptdev = pirq->ptdev; + struct panthor_aw *aw = ptdev->aw; + u32 status; + + scoped_guard(spinlock_irqsave, &pirq->lock) { + if (pirq->state != PANTHOR_IRQ_STATE_ACTIVE) + return IRQ_NONE; + } + + status = gpu_read(pirq->iomem, INT_STAT); + if (!status) + return IRQ_NONE; + + if (status & WINDOW_IRQ_MESSAGE) + panthor_aw_handle_message(aw); + + if (status & WINDOW_IRQ_WINDOW_CLOSED) + panthor_aw_handle_window_closed(aw); + + if (status & WINDOW_IRQ_WINDOW_OPENED) + panthor_aw_handle_window_opened(aw); + + gpu_write(pirq->iomem, INT_CLEAR, status); + + return IRQ_HANDLED; +} + +static void panthor_aw_irq_suspend(struct panthor_irq *pirq) +{ + panthor_irq_suspend(pirq); +} + +static void panthor_aw_irq_resume(struct panthor_irq *pirq) +{ + guard(spinlock_irqsave)(&pirq->lock); + + pirq->state = PANTHOR_IRQ_STATE_ACTIVE; + gpu_write(pirq->iomem, INT_MASK, pirq->mask); +} + +static int panthor_request_aw_irq(struct panthor_device *ptdev, + struct panthor_irq *pirq, int irq, + void __iomem *iomem) +{ + pirq->ptdev = ptdev; + pirq->irq = irq; + pirq->mask = 0; + pirq->iomem = iomem; + spin_lock_init(&pirq->lock); + pirq->state = PANTHOR_IRQ_STATE_SUSPENDED; + + gpu_write(pirq->iomem, INT_MASK, 0); + return devm_request_irq(ptdev->base.dev, irq, panthor_aw_irq_raw_hander, + IRQF_SHARED, "panthor-aw", pirq); +} + +static int panthor_aw_request(struct panthor_aw *aw) +{ + enum panthor_aw_state state; + u32 timeout_ms; + int ret; + +again: + scoped_guard(spinlock_irqsave, &aw->lock) { + state = atomic_read(&aw->state); + + switch (state) { + case PANTHOR_AW_STATE_GPU_GRANTED: + return 0; + case PANTHOR_AW_STATE_SUSPEND_PENDING: + return -EAGAIN; + case PANTHOR_AW_STATE_INIT: + panthor_aw_handshake_init(aw); + timeout_ms = PANTHOR_AW_HANDSHAKE_TIMEOUT_MS; + break; + case PANTHOR_AW_STATE_READY: + if (!panthor_am_msg_supported(&aw->msg)) { + drm_err(&aw->ptdev->base, + "unsupported protocol version 0x%x. MIN: 0x%x CUR: 0x%x", + aw->msg.version, + AM_MSG_MIN_SUPPORTED_VERSION, + AM_MSG_CURRENT_VERSION); + return -EOPNOTSUPP; + } + + panthor_aw_state_set(aw, PANTHOR_AW_STATE_GPU_REQUEST); + panthor_aw_send_msg(aw, VM_ARB_GPU_REQUEST); + fallthrough; + case PANTHOR_AW_STATE_GPU_REQUEST: + timeout_ms = PANTHOR_AW_GPU_REQUEST_TIMEOUT_MS; + break; + case PANTHOR_AW_STATE_YIELDING: + timeout_ms = PANTHOR_AW_STATE_TRANSITION_TIMEOUT_MS; + break; + } + + state = atomic_read(&aw->state); + } + + ret = panthor_aw_wait_cond(aw, atomic_read(&aw->state) != state, timeout_ms); + if (ret) { + scoped_guard(spinlock_irqsave, &aw->lock) { + switch (atomic_read(&aw->state)) { + case PANTHOR_AW_STATE_GPU_GRANTED: + return 0; + case PANTHOR_AW_STATE_GPU_REQUEST: + panthor_aw_state_set(aw, PANTHOR_AW_STATE_READY); + break; + default: + break; + } + } + + return ret; + } + + goto again; +} + +static int __panthor_aw_suspend(struct panthor_aw *aw) +{ + scoped_guard(spinlock_irqsave, &aw->lock) { + switch (atomic_read(&aw->state)) { + case PANTHOR_AW_STATE_READY: + return 0; + case PANTHOR_AW_STATE_SUSPEND_PENDING: + return 0; + case PANTHOR_AW_STATE_GPU_GRANTED: + panthor_aw_state_set(aw, PANTHOR_AW_STATE_YIELDING); + panthor_aw_send_msg(aw, VM_ARB_GPU_STOPPED); + break; + default: + break; + } + } + + return panthor_aw_state_wait(aw, PANTHOR_AW_STATE_READY, + PANTHOR_AW_STATE_TRANSITION_TIMEOUT_MS); +} + +int panthor_aw_init(struct panthor_device *ptdev) +{ + struct panthor_aw *aw; + int irq; + int ret; + + if (!panthor_hw_has_gpu_discover(ptdev)) + return 0; + + aw = drmm_kzalloc(&ptdev->base, sizeof(*aw), GFP_KERNEL); + if (!aw) + return -ENOMEM; + + aw->wq = drmm_alloc_ordered_workqueue(&ptdev->base, "panthor-aw-wq", 0); + if (IS_ERR(aw->wq)) + return PTR_ERR(aw->wq); + + aw->ptdev = ptdev; + aw->iomem = ptdev->iomem; + + INIT_WORK(&aw->msg_retry_work, panthor_aw_msg_retry_work); + + init_waitqueue_head(&aw->waitqueue); + spin_lock_init(&aw->lock); + atomic_set(&aw->state, PANTHOR_AW_STATE_INIT); + + panthor_am_msg_init(&aw->msg, aw->iomem + WINDOW_MESSAGE_BASE); + + ptdev->aw = aw; + + irq = platform_get_irq_byname(to_platform_device(ptdev->base.dev), "gpu"); + if (irq < 0) + return irq; + + ret = panthor_request_aw_irq(ptdev, &aw->irq, irq, aw->iomem + WINDOW_INT_BASE); + if (ret) + return ret; + + panthor_irq_enable_events(&aw->irq, WINDOW_IRQ_MASK); + panthor_aw_irq_resume(&aw->irq); + + ret = panthor_aw_request(aw); + if (ret) + panthor_aw_unplug(ptdev); + + return ret; +} + +void panthor_aw_unplug(struct panthor_device *ptdev) +{ + struct panthor_aw *aw = ptdev->aw; + + if (!aw) + return; + + if (!IS_ENABLED(CONFIG_PM) || pm_runtime_active(ptdev->base.dev)) { + __panthor_aw_suspend(aw); + panthor_aw_irq_suspend(&aw->irq); + } + + disable_work_sync(&aw->msg_retry_work); +} + +int panthor_aw_resume(struct panthor_device *ptdev) +{ + struct panthor_aw *aw = ptdev->aw; + int ret; + + if (!aw) + return 0; + + panthor_aw_irq_resume(&aw->irq); + + ret = panthor_aw_request(aw); + if (ret) { + drm_warn(&ptdev->base, "Timedout waiting for GPU to be granted"); + goto err_out; + } + + return 0; + +err_out: + panthor_aw_irq_suspend(&aw->irq); + return ret; +} + +int panthor_aw_suspend(struct panthor_device *ptdev) +{ + struct panthor_aw *aw = ptdev->aw; + int ret = 0; + + /* suspend hw components directly if AW is not supported */ + if (!aw) + return 0; + + ret = __panthor_aw_suspend(aw); + + panthor_aw_irq_suspend(&aw->irq); + + return ret; +} diff --git a/drivers/gpu/drm/panthor/panthor_aw.h b/drivers/gpu/drm/panthor/panthor_aw.h new file mode 100644 index 0000000000000..60d5c8b6c9afc --- /dev/null +++ b/drivers/gpu/drm/panthor/panthor_aw.h @@ -0,0 +1,42 @@ +/* SPDX-License-Identifier: GPL-2.0 or MIT */ +/* Copyright 2026 ARM Limited. All rights reserved. */ + +#ifndef __PANTHOR_AW_H__ +#define __PANTHOR_AW_H__ + +#include <linux/types.h> + +struct panthor_device; + +/** + * enum panthor_aw_state - Enumeration of possible Access Window states + */ +enum panthor_aw_state { + /** @PANTHOR_AW_STATE_INIT: Initial state, prior to handshake. */ + PANTHOR_AW_STATE_INIT = 0, + + /** @PANTHOR_AW_STATE_READY: Handshake with Resource Group completed. */ + PANTHOR_AW_STATE_READY, + + /** @PANTHOR_AW_STATE_GPU_REQUEST: AW requested for GPU access. */ + PANTHOR_AW_STATE_GPU_REQUEST, + + /** @PANTHOR_AW_STATE_GPU_GRANTED: AW is granted GPU access. */ + PANTHOR_AW_STATE_GPU_GRANTED, + + /** @PANTHOR_AW_STATE_YIELDING: Stopped GPU access, pending close. */ + PANTHOR_AW_STATE_YIELDING, + + /** @PANTHOR_AW_STATE_SUSPEND_PENDING: AW closed, pending host cleanup. */ + PANTHOR_AW_STATE_SUSPEND_PENDING, +}; + +int panthor_aw_init(struct panthor_device *ptdev); + +void panthor_aw_unplug(struct panthor_device *ptdev); + +int panthor_aw_resume(struct panthor_device *ptdev); + +int panthor_aw_suspend(struct panthor_device *ptdev); + +#endif diff --git a/drivers/gpu/drm/panthor/panthor_device.c b/drivers/gpu/drm/panthor/panthor_device.c index 9687c59de3505..98c0dd3ce7bcb 100644 --- a/drivers/gpu/drm/panthor/panthor_device.c +++ b/drivers/gpu/drm/panthor/panthor_device.c @@ -16,6 +16,7 @@ #include <drm/drm_managed.h> #include <drm/drm_print.h> +#include "panthor_aw.h" #include "panthor_devfreq.h" #include "panthor_device.h" #include "panthor_fw.h" @@ -100,6 +101,7 @@ void panthor_device_unplug(struct panthor_device *ptdev) panthor_gem_shrinker_unplug(ptdev); panthor_gpu_unplug(ptdev); panthor_pwr_unplug(ptdev); + panthor_aw_unplug(ptdev); pm_runtime_dont_use_autosuspend(ptdev->base.dev); pm_runtime_put_sync_suspend(ptdev->base.dev); @@ -259,10 +261,18 @@ int panthor_device_init(struct panthor_device *ptdev) if (ret) goto err_rpm_put; - ret = panthor_pwr_init(ptdev); + ret = panthor_aw_init(ptdev); if (ret) goto err_rpm_put; + ret = panthor_hw_info_init(ptdev); + if (ret) + goto err_unplug_aw; + + ret = panthor_pwr_init(ptdev); + if (ret) + goto err_unplug_aw; + ret = panthor_gpu_init(ptdev); if (ret) goto err_unplug_pwr; @@ -322,6 +332,9 @@ int panthor_device_init(struct panthor_device *ptdev) err_unplug_pwr: panthor_pwr_unplug(ptdev); +err_unplug_aw: + panthor_aw_unplug(ptdev); + err_rpm_put: pm_runtime_put_sync_suspend(ptdev->base.dev); return ret; diff --git a/drivers/gpu/drm/panthor/panthor_device.h b/drivers/gpu/drm/panthor/panthor_device.h index f0a96ff0f13da..ede630ddce3e1 100644 --- a/drivers/gpu/drm/panthor/panthor_device.h +++ b/drivers/gpu/drm/panthor/panthor_device.h @@ -21,6 +21,7 @@ #include "panthor_device_io.h" +struct panthor_aw; struct panthor_csf; struct panthor_csf_ctx; struct panthor_device; @@ -202,6 +203,9 @@ struct panthor_device { /** @hw: GPU-specific data. */ struct panthor_hw *hw; + /** @aw: AW-specific data */ + struct panthor_aw *aw; + /** @pwr: Power control management data. */ struct panthor_pwr *pwr; diff --git a/drivers/gpu/drm/panthor/panthor_hw.c b/drivers/gpu/drm/panthor/panthor_hw.c index e8e899c638128..7d40091c1e95a 100644 --- a/drivers/gpu/drm/panthor/panthor_hw.c +++ b/drivers/gpu/drm/panthor/panthor_hw.c @@ -353,7 +353,7 @@ static int panthor_gpu_info_init(struct panthor_device *ptdev) return overload_shader_present(ptdev); } -static int panthor_hw_info_init(struct panthor_device *ptdev) +int panthor_hw_info_init(struct panthor_device *ptdev) { u64 l2_features; u32 prod_id, major, minor, status; @@ -471,9 +471,5 @@ int panthor_hw_init(struct panthor_device *ptdev) if (ret) return ret; - ret = panthor_hw_bind_device(ptdev); - if (ret) - return ret; - - return panthor_hw_info_init(ptdev); + return panthor_hw_bind_device(ptdev); } diff --git a/drivers/gpu/drm/panthor/panthor_hw.h b/drivers/gpu/drm/panthor/panthor_hw.h index dee641c698661..6ca20701f96e1 100644 --- a/drivers/gpu/drm/panthor/panthor_hw.h +++ b/drivers/gpu/drm/panthor/panthor_hw.h @@ -66,6 +66,8 @@ struct panthor_hw { }; int panthor_hw_init(struct panthor_device *ptdev); +int panthor_hw_info_init(struct panthor_device *ptdev); + int panthor_hw_power_status_register(void); void panthor_hw_power_status_unregister(void); -- 2.43.0
