1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright 2019 Linaro, Ltd, Rob Herring <robh@kernel.org> */
3 /* Copyright 2019 Collabora ltd. */
4 #include <linux/delay.h>
5 #include <linux/interrupt.h>
7 #include <linux/platform_device.h>
8 #include <linux/pm_runtime.h>
9 #include <linux/reservation.h>
10 #include <drm/gpu_scheduler.h>
11 #include <drm/panfrost_drm.h>
13 #include "panfrost_device.h"
14 #include "panfrost_devfreq.h"
15 #include "panfrost_job.h"
16 #include "panfrost_features.h"
17 #include "panfrost_issues.h"
18 #include "panfrost_gem.h"
19 #include "panfrost_regs.h"
20 #include "panfrost_gpu.h"
21 #include "panfrost_mmu.h"
23 #define job_write(dev, reg, data) writel(data, dev->iomem + (reg))
24 #define job_read(dev, reg) readl(dev->iomem + (reg))
26 struct panfrost_queue_state {
27 struct drm_gpu_scheduler sched;
33 struct panfrost_job_slot {
34 struct panfrost_queue_state queue[NUM_JOB_SLOTS];
38 static struct panfrost_job *
39 to_panfrost_job(struct drm_sched_job *sched_job)
41 return container_of(sched_job, struct panfrost_job, base);
44 struct panfrost_fence {
45 struct dma_fence base;
46 struct drm_device *dev;
47 /* panfrost seqno for signaled() test */
52 static inline struct panfrost_fence *
53 to_panfrost_fence(struct dma_fence *fence)
55 return (struct panfrost_fence *)fence;
58 static const char *panfrost_fence_get_driver_name(struct dma_fence *fence)
63 static const char *panfrost_fence_get_timeline_name(struct dma_fence *fence)
65 struct panfrost_fence *f = to_panfrost_fence(fence);
69 return "panfrost-js-0";
71 return "panfrost-js-1";
73 return "panfrost-js-2";
79 static const struct dma_fence_ops panfrost_fence_ops = {
80 .get_driver_name = panfrost_fence_get_driver_name,
81 .get_timeline_name = panfrost_fence_get_timeline_name,
84 static struct dma_fence *panfrost_fence_create(struct panfrost_device *pfdev, int js_num)
86 struct panfrost_fence *fence;
87 struct panfrost_job_slot *js = pfdev->js;
89 fence = kzalloc(sizeof(*fence), GFP_KERNEL);
91 return ERR_PTR(-ENOMEM);
93 fence->dev = pfdev->ddev;
94 fence->queue = js_num;
95 fence->seqno = ++js->queue[js_num].emit_seqno;
96 dma_fence_init(&fence->base, &panfrost_fence_ops, &js->job_lock,
97 js->queue[js_num].fence_context, fence->seqno);
102 static int panfrost_job_get_slot(struct panfrost_job *job)
104 /* JS0: fragment jobs.
105 * JS1: vertex/tiler jobs
108 if (job->requirements & PANFROST_JD_REQ_FS)
111 /* Not exposed to userspace yet */
113 if (job->requirements & PANFROST_JD_REQ_ONLY_COMPUTE) {
114 if ((job->requirements & PANFROST_JD_REQ_CORE_GRP_MASK) &&
115 (job->pfdev->features.nr_core_groups == 2))
117 if (panfrost_has_hw_issue(job->pfdev, HW_ISSUE_8987))
124 static void panfrost_job_write_affinity(struct panfrost_device *pfdev,
131 * Use all cores for now.
132 * Eventually we may need to support tiler only jobs and h/w with
133 * multiple (2) coherent core groups
135 affinity = pfdev->features.shader_present;
137 job_write(pfdev, JS_AFFINITY_NEXT_LO(js), affinity & 0xFFFFFFFF);
138 job_write(pfdev, JS_AFFINITY_NEXT_HI(js), affinity >> 32);
141 static void panfrost_job_hw_submit(struct panfrost_job *job, int js)
143 struct panfrost_device *pfdev = job->pfdev;
146 u64 jc_head = job->jc;
149 ret = pm_runtime_get_sync(pfdev->dev);
153 if (WARN_ON(job_read(pfdev, JS_COMMAND_NEXT(js))))
156 panfrost_devfreq_record_transition(pfdev, js);
157 spin_lock_irqsave(&pfdev->hwaccess_lock, flags);
159 job_write(pfdev, JS_HEAD_NEXT_LO(js), jc_head & 0xFFFFFFFF);
160 job_write(pfdev, JS_HEAD_NEXT_HI(js), jc_head >> 32);
162 panfrost_job_write_affinity(pfdev, job->requirements, js);
164 /* start MMU, medium priority, cache clean/flush on end, clean/flush on
166 /* TODO: different address spaces */
167 cfg = JS_CONFIG_THREAD_PRI(8) |
168 JS_CONFIG_START_FLUSH_CLEAN_INVALIDATE |
169 JS_CONFIG_END_FLUSH_CLEAN_INVALIDATE;
171 if (panfrost_has_hw_feature(pfdev, HW_FEATURE_FLUSH_REDUCTION))
172 cfg |= JS_CONFIG_ENABLE_FLUSH_REDUCTION;
174 if (panfrost_has_hw_issue(pfdev, HW_ISSUE_10649))
175 cfg |= JS_CONFIG_START_MMU;
177 job_write(pfdev, JS_CONFIG_NEXT(js), cfg);
179 if (panfrost_has_hw_feature(pfdev, HW_FEATURE_FLUSH_REDUCTION))
180 job_write(pfdev, JS_FLUSH_ID_NEXT(js), job->flush_id);
183 dev_dbg(pfdev->dev, "JS: Submitting atom %p to js[%d] with head=0x%llx",
186 job_write(pfdev, JS_COMMAND_NEXT(js), JS_COMMAND_START);
188 spin_unlock_irqrestore(&pfdev->hwaccess_lock, flags);
191 pm_runtime_mark_last_busy(pfdev->dev);
192 pm_runtime_put_autosuspend(pfdev->dev);
195 static void panfrost_acquire_object_fences(struct drm_gem_object **bos,
197 struct dma_fence **implicit_fences)
201 for (i = 0; i < bo_count; i++)
202 implicit_fences[i] = reservation_object_get_excl_rcu(bos[i]->resv);
205 static void panfrost_attach_object_fences(struct drm_gem_object **bos,
207 struct dma_fence *fence)
211 for (i = 0; i < bo_count; i++)
212 reservation_object_add_excl_fence(bos[i]->resv, fence);
215 int panfrost_job_push(struct panfrost_job *job)
217 struct panfrost_device *pfdev = job->pfdev;
218 int slot = panfrost_job_get_slot(job);
219 struct drm_sched_entity *entity = &job->file_priv->sched_entity[slot];
220 struct ww_acquire_ctx acquire_ctx;
223 mutex_lock(&pfdev->sched_lock);
225 ret = drm_gem_lock_reservations(job->bos, job->bo_count,
228 mutex_unlock(&pfdev->sched_lock);
232 ret = drm_sched_job_init(&job->base, entity, NULL);
234 mutex_unlock(&pfdev->sched_lock);
238 job->render_done_fence = dma_fence_get(&job->base.s_fence->finished);
240 kref_get(&job->refcount); /* put by scheduler job completion */
242 panfrost_acquire_object_fences(job->bos, job->bo_count,
243 job->implicit_fences);
245 drm_sched_entity_push_job(&job->base, entity);
247 mutex_unlock(&pfdev->sched_lock);
249 panfrost_attach_object_fences(job->bos, job->bo_count,
250 job->render_done_fence);
253 drm_gem_unlock_reservations(job->bos, job->bo_count, &acquire_ctx);
258 static void panfrost_job_cleanup(struct kref *ref)
260 struct panfrost_job *job = container_of(ref, struct panfrost_job,
264 if (job->in_fences) {
265 for (i = 0; i < job->in_fence_count; i++)
266 dma_fence_put(job->in_fences[i]);
267 kvfree(job->in_fences);
269 if (job->implicit_fences) {
270 for (i = 0; i < job->bo_count; i++)
271 dma_fence_put(job->implicit_fences[i]);
272 kvfree(job->implicit_fences);
274 dma_fence_put(job->done_fence);
275 dma_fence_put(job->render_done_fence);
278 for (i = 0; i < job->bo_count; i++)
279 drm_gem_object_put_unlocked(job->bos[i]);
286 void panfrost_job_put(struct panfrost_job *job)
288 kref_put(&job->refcount, panfrost_job_cleanup);
291 static void panfrost_job_free(struct drm_sched_job *sched_job)
293 struct panfrost_job *job = to_panfrost_job(sched_job);
295 drm_sched_job_cleanup(sched_job);
297 panfrost_job_put(job);
300 static struct dma_fence *panfrost_job_dependency(struct drm_sched_job *sched_job,
301 struct drm_sched_entity *s_entity)
303 struct panfrost_job *job = to_panfrost_job(sched_job);
304 struct dma_fence *fence;
307 /* Explicit fences */
308 for (i = 0; i < job->in_fence_count; i++) {
309 if (job->in_fences[i]) {
310 fence = job->in_fences[i];
311 job->in_fences[i] = NULL;
316 /* Implicit fences, max. one per BO */
317 for (i = 0; i < job->bo_count; i++) {
318 if (job->implicit_fences[i]) {
319 fence = job->implicit_fences[i];
320 job->implicit_fences[i] = NULL;
328 static struct dma_fence *panfrost_job_run(struct drm_sched_job *sched_job)
330 struct panfrost_job *job = to_panfrost_job(sched_job);
331 struct panfrost_device *pfdev = job->pfdev;
332 int slot = panfrost_job_get_slot(job);
333 struct dma_fence *fence = NULL;
335 if (unlikely(job->base.s_fence->finished.error))
338 pfdev->jobs[slot] = job;
340 fence = panfrost_fence_create(pfdev, slot);
345 dma_fence_put(job->done_fence);
346 job->done_fence = dma_fence_get(fence);
348 panfrost_job_hw_submit(job, slot);
353 void panfrost_job_enable_interrupts(struct panfrost_device *pfdev)
358 for (j = 0; j < NUM_JOB_SLOTS; j++) {
359 irq_mask |= MK_JS_MASK(j);
362 job_write(pfdev, JOB_INT_CLEAR, irq_mask);
363 job_write(pfdev, JOB_INT_MASK, irq_mask);
366 static void panfrost_job_timedout(struct drm_sched_job *sched_job)
368 struct panfrost_job *job = to_panfrost_job(sched_job);
369 struct panfrost_device *pfdev = job->pfdev;
370 int js = panfrost_job_get_slot(job);
374 * If the GPU managed to complete this jobs fence, the timeout is
375 * spurious. Bail out.
377 if (dma_fence_is_signaled(job->done_fence))
380 dev_err(pfdev->dev, "gpu sched timeout, js=%d, status=0x%x, head=0x%x, tail=0x%x, sched_job=%p",
382 job_read(pfdev, JS_STATUS(js)),
383 job_read(pfdev, JS_HEAD_LO(js)),
384 job_read(pfdev, JS_TAIL_LO(js)),
387 if (!mutex_trylock(&pfdev->reset_lock))
390 for (i = 0; i < NUM_JOB_SLOTS; i++) {
391 struct drm_gpu_scheduler *sched = &pfdev->js->queue[i].sched;
393 drm_sched_stop(sched, sched_job);
395 /* Ensure any timeouts on other slots have finished */
396 cancel_delayed_work_sync(&sched->work_tdr);
399 drm_sched_increase_karma(sched_job);
401 /* panfrost_core_dump(pfdev); */
403 panfrost_devfreq_record_transition(pfdev, js);
404 panfrost_gpu_soft_reset(pfdev);
406 /* TODO: Re-enable all other address spaces */
407 panfrost_mmu_enable(pfdev, 0);
408 panfrost_gpu_power_on(pfdev);
409 panfrost_job_enable_interrupts(pfdev);
411 for (i = 0; i < NUM_JOB_SLOTS; i++)
412 drm_sched_resubmit_jobs(&pfdev->js->queue[i].sched);
414 /* restart scheduler after GPU is usable again */
415 for (i = 0; i < NUM_JOB_SLOTS; i++)
416 drm_sched_start(&pfdev->js->queue[i].sched, true);
418 mutex_unlock(&pfdev->reset_lock);
421 static const struct drm_sched_backend_ops panfrost_sched_ops = {
422 .dependency = panfrost_job_dependency,
423 .run_job = panfrost_job_run,
424 .timedout_job = panfrost_job_timedout,
425 .free_job = panfrost_job_free
428 static irqreturn_t panfrost_job_irq_handler(int irq, void *data)
430 struct panfrost_device *pfdev = data;
431 u32 status = job_read(pfdev, JOB_INT_STAT);
434 dev_dbg(pfdev->dev, "jobslot irq status=%x\n", status);
439 pm_runtime_mark_last_busy(pfdev->dev);
441 for (j = 0; status; j++) {
442 u32 mask = MK_JS_MASK(j);
444 if (!(status & mask))
447 job_write(pfdev, JOB_INT_CLEAR, mask);
449 if (status & JOB_INT_MASK_ERR(j)) {
450 job_write(pfdev, JS_COMMAND_NEXT(j), JS_COMMAND_NOP);
452 dev_err(pfdev->dev, "js fault, js=%d, status=%s, head=0x%x, tail=0x%x",
454 panfrost_exception_name(pfdev, job_read(pfdev, JS_STATUS(j))),
455 job_read(pfdev, JS_HEAD_LO(j)),
456 job_read(pfdev, JS_TAIL_LO(j)));
458 drm_sched_fault(&pfdev->js->queue[j].sched);
461 if (status & JOB_INT_MASK_DONE(j)) {
462 panfrost_devfreq_record_transition(pfdev, j);
463 dma_fence_signal(pfdev->jobs[j]->done_fence);
472 int panfrost_job_init(struct panfrost_device *pfdev)
474 struct panfrost_job_slot *js;
477 pfdev->js = js = devm_kzalloc(pfdev->dev, sizeof(*js), GFP_KERNEL);
481 spin_lock_init(&js->job_lock);
483 irq = platform_get_irq_byname(to_platform_device(pfdev->dev), "job");
487 ret = devm_request_irq(pfdev->dev, irq, panfrost_job_irq_handler,
488 IRQF_SHARED, "job", pfdev);
490 dev_err(pfdev->dev, "failed to request job irq");
494 for (j = 0; j < NUM_JOB_SLOTS; j++) {
495 js->queue[j].fence_context = dma_fence_context_alloc(1);
497 ret = drm_sched_init(&js->queue[j].sched,
499 1, 0, msecs_to_jiffies(500),
502 dev_err(pfdev->dev, "Failed to create scheduler: %d.", ret);
507 panfrost_job_enable_interrupts(pfdev);
512 for (j--; j >= 0; j--)
513 drm_sched_fini(&js->queue[j].sched);
518 void panfrost_job_fini(struct panfrost_device *pfdev)
520 struct panfrost_job_slot *js = pfdev->js;
523 job_write(pfdev, JOB_INT_MASK, 0);
525 for (j = 0; j < NUM_JOB_SLOTS; j++)
526 drm_sched_fini(&js->queue[j].sched);
530 int panfrost_job_open(struct panfrost_file_priv *panfrost_priv)
532 struct panfrost_device *pfdev = panfrost_priv->pfdev;
533 struct panfrost_job_slot *js = pfdev->js;
534 struct drm_sched_rq *rq;
537 for (i = 0; i < NUM_JOB_SLOTS; i++) {
538 rq = &js->queue[i].sched.sched_rq[DRM_SCHED_PRIORITY_NORMAL];
539 ret = drm_sched_entity_init(&panfrost_priv->sched_entity[i], &rq, 1, NULL);
546 void panfrost_job_close(struct panfrost_file_priv *panfrost_priv)
550 for (i = 0; i < NUM_JOB_SLOTS; i++)
551 drm_sched_entity_destroy(&panfrost_priv->sched_entity[i]);
554 int panfrost_job_is_idle(struct panfrost_device *pfdev)
556 struct panfrost_job_slot *js = pfdev->js;
559 for (i = 0; i < NUM_JOB_SLOTS; i++) {
560 /* If there are any jobs in the HW queue, we're not idle */
561 if (atomic_read(&js->queue[i].sched.hw_rq_count))
564 /* Check whether the hardware is idle */
565 if (pfdev->devfreq.slot[i].busy)