// SPDX-License-Identifier: GPL-2.0 /* Copyright 2019 Linaro, Ltd, Rob Herring */ /* Copyright 2019 Collabora ltd. */ #include #include #include #include #include #include #include #include #include "panfrost_device.h" #include "panfrost_devfreq.h" #include "panfrost_job.h" #include "panfrost_features.h" #include "panfrost_issues.h" #include "panfrost_gem.h" #include "panfrost_regs.h" #include "panfrost_gpu.h" #include "panfrost_mmu.h" #define JOB_TIMEOUT_MS 500 #define job_write(dev, reg, data) writel(data, dev->iomem + (reg)) #define job_read(dev, reg) readl(dev->iomem + (reg)) enum panfrost_queue_status { PANFROST_QUEUE_STATUS_ACTIVE, PANFROST_QUEUE_STATUS_STOPPED, PANFROST_QUEUE_STATUS_STARTING, PANFROST_QUEUE_STATUS_FAULT_PENDING, }; struct panfrost_queue_state { struct drm_gpu_scheduler sched; atomic_t status; struct mutex lock; u64 fence_context; u64 emit_seqno; }; struct panfrost_job_slot { struct panfrost_queue_state queue[NUM_JOB_SLOTS]; spinlock_t job_lock; }; static struct panfrost_job * to_panfrost_job(struct drm_sched_job *sched_job) { return container_of(sched_job, struct panfrost_job, base); } struct panfrost_fence { struct dma_fence base; struct drm_device *dev; /* panfrost seqno for signaled() test */ u64 seqno; int queue; }; static inline struct panfrost_fence * to_panfrost_fence(struct dma_fence *fence) { return (struct panfrost_fence *)fence; } static const char *panfrost_fence_get_driver_name(struct dma_fence *fence) { return "panfrost"; } static const char *panfrost_fence_get_timeline_name(struct dma_fence *fence) { struct panfrost_fence *f = to_panfrost_fence(fence); switch (f->queue) { case 0: return "panfrost-js-0"; case 1: return "panfrost-js-1"; case 2: return "panfrost-js-2"; default: return NULL; } } static const struct dma_fence_ops panfrost_fence_ops = { .get_driver_name = panfrost_fence_get_driver_name, .get_timeline_name = panfrost_fence_get_timeline_name, }; static struct dma_fence *panfrost_fence_create(struct panfrost_device *pfdev, int js_num) { struct panfrost_fence *fence; struct panfrost_job_slot *js = pfdev->js; fence = kzalloc(sizeof(*fence), GFP_KERNEL); if (!fence) return ERR_PTR(-ENOMEM); fence->dev = pfdev->ddev; fence->queue = js_num; fence->seqno = ++js->queue[js_num].emit_seqno; dma_fence_init(&fence->base, &panfrost_fence_ops, &js->job_lock, js->queue[js_num].fence_context, fence->seqno); return &fence->base; } static int panfrost_job_get_slot(struct panfrost_job *job) { /* JS0: fragment jobs. * JS1: vertex/tiler jobs * JS2: compute jobs */ if (job->requirements & PANFROST_JD_REQ_FS) return 0; /* Not exposed to userspace yet */ #if 0 if (job->requirements & PANFROST_JD_REQ_ONLY_COMPUTE) { if ((job->requirements & PANFROST_JD_REQ_CORE_GRP_MASK) && (job->pfdev->features.nr_core_groups == 2)) return 2; if (panfrost_has_hw_issue(job->pfdev, HW_ISSUE_8987)) return 2; } #endif return 1; } static void panfrost_job_write_affinity(struct panfrost_device *pfdev, u32 requirements, int js) { u64 affinity; /* * Use all cores for now. * Eventually we may need to support tiler only jobs and h/w with * multiple (2) coherent core groups */ affinity = pfdev->features.shader_present; job_write(pfdev, JS_AFFINITY_NEXT_LO(js), affinity & 0xFFFFFFFF); job_write(pfdev, JS_AFFINITY_NEXT_HI(js), affinity >> 32); } static void panfrost_job_hw_submit(struct panfrost_job *job, int js) { struct panfrost_device *pfdev = job->pfdev; u32 cfg; u64 jc_head = job->jc; int ret; panfrost_devfreq_record_busy(&pfdev->pfdevfreq); ret = pm_runtime_get_sync(pfdev->dev); if (ret < 0) return; if (WARN_ON(job_read(pfdev, JS_COMMAND_NEXT(js)))) { return; } cfg = panfrost_mmu_as_get(pfdev, &job->file_priv->mmu); job_write(pfdev, JS_HEAD_NEXT_LO(js), jc_head & 0xFFFFFFFF); job_write(pfdev, JS_HEAD_NEXT_HI(js), jc_head >> 32); panfrost_job_write_affinity(pfdev, job->requirements, js); /* start MMU, medium priority, cache clean/flush on end, clean/flush on * start */ cfg |= JS_CONFIG_THREAD_PRI(8) | JS_CONFIG_START_FLUSH_CLEAN_INVALIDATE | JS_CONFIG_END_FLUSH_CLEAN_INVALIDATE; if (panfrost_has_hw_feature(pfdev, HW_FEATURE_FLUSH_REDUCTION)) cfg |= JS_CONFIG_ENABLE_FLUSH_REDUCTION; if (panfrost_has_hw_issue(pfdev, HW_ISSUE_10649)) cfg |= JS_CONFIG_START_MMU; job_write(pfdev, JS_CONFIG_NEXT(js), cfg); if (panfrost_has_hw_feature(pfdev, HW_FEATURE_FLUSH_REDUCTION)) job_write(pfdev, JS_FLUSH_ID_NEXT(js), job->flush_id); /* GO ! */ dev_dbg(pfdev->dev, "JS: Submitting atom %p to js[%d] with head=0x%llx", job, js, jc_head); job_write(pfdev, JS_COMMAND_NEXT(js), JS_COMMAND_START); } static void panfrost_acquire_object_fences(struct drm_gem_object **bos, int bo_count, struct dma_fence **implicit_fences) { int i; for (i = 0; i < bo_count; i++) implicit_fences[i] = dma_resv_get_excl_rcu(bos[i]->resv); } static void panfrost_attach_object_fences(struct drm_gem_object **bos, int bo_count, struct dma_fence *fence) { int i; for (i = 0; i < bo_count; i++) dma_resv_add_excl_fence(bos[i]->resv, fence); } int panfrost_job_push(struct panfrost_job *job) { struct panfrost_device *pfdev = job->pfdev; int slot = panfrost_job_get_slot(job); struct drm_sched_entity *entity = &job->file_priv->sched_entity[slot]; struct ww_acquire_ctx acquire_ctx; int ret = 0; mutex_lock(&pfdev->sched_lock); ret = drm_gem_lock_reservations(job->bos, job->bo_count, &acquire_ctx); if (ret) { mutex_unlock(&pfdev->sched_lock); return ret; } ret = drm_sched_job_init(&job->base, entity, NULL); if (ret) { mutex_unlock(&pfdev->sched_lock); goto unlock; } job->render_done_fence = dma_fence_get(&job->base.s_fence->finished); kref_get(&job->refcount); /* put by scheduler job completion */ panfrost_acquire_object_fences(job->bos, job->bo_count, job->implicit_fences); drm_sched_entity_push_job(&job->base, entity); mutex_unlock(&pfdev->sched_lock); panfrost_attach_object_fences(job->bos, job->bo_count, job->render_done_fence); unlock: drm_gem_unlock_reservations(job->bos, job->bo_count, &acquire_ctx); return ret; } static void panfrost_job_cleanup(struct kref *ref) { struct panfrost_job *job = container_of(ref, struct panfrost_job, refcount); unsigned int i; if (job->in_fences) { for (i = 0; i < job->in_fence_count; i++) dma_fence_put(job->in_fences[i]); kvfree(job->in_fences); } if (job->implicit_fences) { for (i = 0; i < job->bo_count; i++) dma_fence_put(job->implicit_fences[i]); kvfree(job->implicit_fences); } dma_fence_put(job->done_fence); dma_fence_put(job->render_done_fence); if (job->mappings) { for (i = 0; i < job->bo_count; i++) { if (!job->mappings[i]) break; atomic_dec(&job->mappings[i]->obj->gpu_usecount); panfrost_gem_mapping_put(job->mappings[i]); } kvfree(job->mappings); } if (job->bos) { for (i = 0; i < job->bo_count; i++) drm_gem_object_put(job->bos[i]); kvfree(job->bos); } kfree(job); } void panfrost_job_put(struct panfrost_job *job) { kref_put(&job->refcount, panfrost_job_cleanup); } static void panfrost_job_free(struct drm_sched_job *sched_job) { struct panfrost_job *job = to_panfrost_job(sched_job); drm_sched_job_cleanup(sched_job); panfrost_job_put(job); } static struct dma_fence *panfrost_job_dependency(struct drm_sched_job *sched_job, struct drm_sched_entity *s_entity) { struct panfrost_job *job = to_panfrost_job(sched_job); struct dma_fence *fence; unsigned int i; /* Explicit fences */ for (i = 0; i < job->in_fence_count; i++) { if (job->in_fences[i]) { fence = job->in_fences[i]; job->in_fences[i] = NULL; return fence; } } /* Implicit fences, max. one per BO */ for (i = 0; i < job->bo_count; i++) { if (job->implicit_fences[i]) { fence = job->implicit_fences[i]; job->implicit_fences[i] = NULL; return fence; } } return NULL; } static struct dma_fence *panfrost_job_run(struct drm_sched_job *sched_job) { struct panfrost_job *job = to_panfrost_job(sched_job); struct panfrost_device *pfdev = job->pfdev; int slot = panfrost_job_get_slot(job); struct dma_fence *fence = NULL; if (unlikely(job->base.s_fence->finished.error)) return NULL; pfdev->jobs[slot] = job; fence = panfrost_fence_create(pfdev, slot); if (IS_ERR(fence)) return NULL; if (job->done_fence) dma_fence_put(job->done_fence); job->done_fence = dma_fence_get(fence); panfrost_job_hw_submit(job, slot); return fence; } void panfrost_job_enable_interrupts(struct panfrost_device *pfdev) { int j; u32 irq_mask = 0; for (j = 0; j < NUM_JOB_SLOTS; j++) { irq_mask |= MK_JS_MASK(j); } job_write(pfdev, JOB_INT_CLEAR, irq_mask); job_write(pfdev, JOB_INT_MASK, irq_mask); } static bool panfrost_scheduler_stop(struct panfrost_queue_state *queue, struct drm_sched_job *bad) { enum panfrost_queue_status old_status; bool stopped = false; mutex_lock(&queue->lock); old_status = atomic_xchg(&queue->status, PANFROST_QUEUE_STATUS_STOPPED); if (old_status == PANFROST_QUEUE_STATUS_STOPPED) goto out; WARN_ON(old_status != PANFROST_QUEUE_STATUS_ACTIVE); drm_sched_stop(&queue->sched, bad); if (bad) drm_sched_increase_karma(bad); stopped = true; /* * Set the timeout to max so the timer doesn't get started * when we return from the timeout handler (restored in * panfrost_scheduler_start()). */ queue->sched.timeout = MAX_SCHEDULE_TIMEOUT; out: mutex_unlock(&queue->lock); return stopped; } static void panfrost_scheduler_start(struct panfrost_queue_state *queue) { enum panfrost_queue_status old_status; mutex_lock(&queue->lock); old_status = atomic_xchg(&queue->status, PANFROST_QUEUE_STATUS_STARTING); WARN_ON(old_status != PANFROST_QUEUE_STATUS_STOPPED); /* Restore the original timeout before starting the scheduler. */ queue->sched.timeout = msecs_to_jiffies(JOB_TIMEOUT_MS); drm_sched_resubmit_jobs(&queue->sched); drm_sched_start(&queue->sched, true); old_status = atomic_xchg(&queue->status, PANFROST_QUEUE_STATUS_ACTIVE); if (old_status == PANFROST_QUEUE_STATUS_FAULT_PENDING) drm_sched_fault(&queue->sched); mutex_unlock(&queue->lock); } static enum drm_gpu_sched_stat panfrost_job_timedout(struct drm_sched_job *sched_job) { struct panfrost_job *job = to_panfrost_job(sched_job); struct panfrost_device *pfdev = job->pfdev; int js = panfrost_job_get_slot(job); /* * If the GPU managed to complete this jobs fence, the timeout is * spurious. Bail out. */ if (dma_fence_is_signaled(job->done_fence)) return DRM_GPU_SCHED_STAT_NOMINAL; dev_err(pfdev->dev, "gpu sched timeout, js=%d, config=0x%x, status=0x%x, head=0x%x, tail=0x%x, sched_job=%p", js, job_read(pfdev, JS_CONFIG(js)), job_read(pfdev, JS_STATUS(js)), job_read(pfdev, JS_HEAD_LO(js)), job_read(pfdev, JS_TAIL_LO(js)), sched_job); /* Scheduler is already stopped, nothing to do. */ if (!panfrost_scheduler_stop(&pfdev->js->queue[js], sched_job)) return DRM_GPU_SCHED_STAT_NOMINAL; /* Schedule a reset if there's no reset in progress. */ if (!atomic_xchg(&pfdev->reset.pending, 1)) schedule_work(&pfdev->reset.work); return DRM_GPU_SCHED_STAT_NOMINAL; } static const struct drm_sched_backend_ops panfrost_sched_ops = { .dependency = panfrost_job_dependency, .run_job = panfrost_job_run, .timedout_job = panfrost_job_timedout, .free_job = panfrost_job_free }; static irqreturn_t panfrost_job_irq_handler(int irq, void *data) { struct panfrost_device *pfdev = data; u32 status = job_read(pfdev, JOB_INT_STAT); int j; dev_dbg(pfdev->dev, "jobslot irq status=%x\n", status); if (!status) return IRQ_NONE; pm_runtime_mark_last_busy(pfdev->dev); for (j = 0; status; j++) { u32 mask = MK_JS_MASK(j); if (!(status & mask)) continue; job_write(pfdev, JOB_INT_CLEAR, mask); if (status & JOB_INT_MASK_ERR(j)) { enum panfrost_queue_status old_status; job_write(pfdev, JS_COMMAND_NEXT(j), JS_COMMAND_NOP); dev_err(pfdev->dev, "js fault, js=%d, status=%s, head=0x%x, tail=0x%x", j, panfrost_exception_name(pfdev, job_read(pfdev, JS_STATUS(j))), job_read(pfdev, JS_HEAD_LO(j)), job_read(pfdev, JS_TAIL_LO(j))); /* * When the queue is being restarted we don't report * faults directly to avoid races between the timeout * and reset handlers. panfrost_scheduler_start() will * call drm_sched_fault() after the queue has been * started if status == FAULT_PENDING. */ old_status = atomic_cmpxchg(&pfdev->js->queue[j].status, PANFROST_QUEUE_STATUS_STARTING, PANFROST_QUEUE_STATUS_FAULT_PENDING); if (old_status == PANFROST_QUEUE_STATUS_ACTIVE) drm_sched_fault(&pfdev->js->queue[j].sched); } if (status & JOB_INT_MASK_DONE(j)) { struct panfrost_job *job; spin_lock(&pfdev->js->job_lock); job = pfdev->jobs[j]; /* Only NULL if job timeout occurred */ if (job) { pfdev->jobs[j] = NULL; panfrost_mmu_as_put(pfdev, &job->file_priv->mmu); panfrost_devfreq_record_idle(&pfdev->pfdevfreq); dma_fence_signal_locked(job->done_fence); pm_runtime_put_autosuspend(pfdev->dev); } spin_unlock(&pfdev->js->job_lock); } status &= ~mask; } return IRQ_HANDLED; } static void panfrost_reset(struct work_struct *work) { struct panfrost_device *pfdev = container_of(work, struct panfrost_device, reset.work); unsigned long flags; unsigned int i; bool cookie; cookie = dma_fence_begin_signalling(); for (i = 0; i < NUM_JOB_SLOTS; i++) { /* * We want pending timeouts to be handled before we attempt * to stop the scheduler. If we don't do that and the timeout * handler is in flight, it might have removed the bad job * from the list, and we'll lose this job if the reset handler * enters the critical section in panfrost_scheduler_stop() * before the timeout handler. * * Timeout is set to MAX_SCHEDULE_TIMEOUT - 1 because we need * something big enough to make sure the timer will not expire * before we manage to stop the scheduler, but we can't use * MAX_SCHEDULE_TIMEOUT because drm_sched_get_cleanup_job() * considers that as 'timer is not running' and will dequeue * the job without making sure the timeout handler is not * running. */ pfdev->js->queue[i].sched.timeout = MAX_SCHEDULE_TIMEOUT - 1; cancel_delayed_work_sync(&pfdev->js->queue[i].sched.work_tdr); panfrost_scheduler_stop(&pfdev->js->queue[i], NULL); } /* All timers have been stopped, we can safely reset the pending state. */ atomic_set(&pfdev->reset.pending, 0); spin_lock_irqsave(&pfdev->js->job_lock, flags); for (i = 0; i < NUM_JOB_SLOTS; i++) { if (pfdev->jobs[i]) { pm_runtime_put_noidle(pfdev->dev); panfrost_devfreq_record_idle(&pfdev->pfdevfreq); pfdev->jobs[i] = NULL; } } spin_unlock_irqrestore(&pfdev->js->job_lock, flags); panfrost_device_reset(pfdev); for (i = 0; i < NUM_JOB_SLOTS; i++) panfrost_scheduler_start(&pfdev->js->queue[i]); dma_fence_end_signalling(cookie); } int panfrost_job_init(struct panfrost_device *pfdev) { struct panfrost_job_slot *js; int ret, j, irq; INIT_WORK(&pfdev->reset.work, panfrost_reset); pfdev->js = js = devm_kzalloc(pfdev->dev, sizeof(*js), GFP_KERNEL); if (!js) return -ENOMEM; spin_lock_init(&js->job_lock); irq = platform_get_irq_byname(to_platform_device(pfdev->dev), "job"); if (irq <= 0) return -ENODEV; ret = devm_request_irq(pfdev->dev, irq, panfrost_job_irq_handler, IRQF_SHARED, KBUILD_MODNAME "-job", pfdev); if (ret) { dev_err(pfdev->dev, "failed to request job irq"); return ret; } for (j = 0; j < NUM_JOB_SLOTS; j++) { mutex_init(&js->queue[j].lock); js->queue[j].fence_context = dma_fence_context_alloc(1); ret = drm_sched_init(&js->queue[j].sched, &panfrost_sched_ops, 1, 0, msecs_to_jiffies(JOB_TIMEOUT_MS), NULL, "pan_js"); if (ret) { dev_err(pfdev->dev, "Failed to create scheduler: %d.", ret); goto err_sched; } } panfrost_job_enable_interrupts(pfdev); return 0; err_sched: for (j--; j >= 0; j--) drm_sched_fini(&js->queue[j].sched); return ret; } void panfrost_job_fini(struct panfrost_device *pfdev) { struct panfrost_job_slot *js = pfdev->js; int j; job_write(pfdev, JOB_INT_MASK, 0); for (j = 0; j < NUM_JOB_SLOTS; j++) { drm_sched_fini(&js->queue[j].sched); mutex_destroy(&js->queue[j].lock); } } int panfrost_job_open(struct panfrost_file_priv *panfrost_priv) { struct panfrost_device *pfdev = panfrost_priv->pfdev; struct panfrost_job_slot *js = pfdev->js; struct drm_gpu_scheduler *sched; int ret, i; for (i = 0; i < NUM_JOB_SLOTS; i++) { sched = &js->queue[i].sched; ret = drm_sched_entity_init(&panfrost_priv->sched_entity[i], DRM_SCHED_PRIORITY_NORMAL, &sched, 1, NULL); if (WARN_ON(ret)) return ret; } return 0; } void panfrost_job_close(struct panfrost_file_priv *panfrost_priv) { int i; for (i = 0; i < NUM_JOB_SLOTS; i++) drm_sched_entity_destroy(&panfrost_priv->sched_entity[i]); } int panfrost_job_is_idle(struct panfrost_device *pfdev) { struct panfrost_job_slot *js = pfdev->js; int i; for (i = 0; i < NUM_JOB_SLOTS; i++) { /* If there are any jobs in the HW queue, we're not idle */ if (atomic_read(&js->queue[i].sched.hw_rq_count)) return false; } return true; }