132 lines · c
1/* SPDX-License-Identifier: GPL-2.0-only */2/*3 * Tegra host1x Syncpoints4 *5 * Copyright (c) 2010-2013, NVIDIA Corporation.6 */7 8#ifndef __HOST1X_SYNCPT_H9#define __HOST1X_SYNCPT_H10 11#include <linux/atomic.h>12#include <linux/host1x.h>13#include <linux/kernel.h>14#include <linux/kref.h>15#include <linux/sched.h>16 17#include "fence.h"18#include "intr.h"19 20struct host1x;21 22/* Reserved for replacing an expired wait with a NOP */23#define HOST1X_SYNCPT_RESERVED 024 25struct host1x_syncpt_base {26 unsigned int id;27 bool requested;28};29 30struct host1x_syncpt {31 struct kref ref;32 33 unsigned int id;34 atomic_t min_val;35 atomic_t max_val;36 u32 base_val;37 const char *name;38 bool client_managed;39 struct host1x *host;40 struct host1x_syncpt_base *base;41 42 /* interrupt data */43 struct host1x_fence_list fences;44 45 /*46 * If a submission incrementing this syncpoint fails, lock it so that47 * further submission cannot be made until application has handled the48 * failure.49 */50 bool locked;51};52 53/* Initialize sync point array */54int host1x_syncpt_init(struct host1x *host);55 56/* Free sync point array */57void host1x_syncpt_deinit(struct host1x *host);58 59/* Return number of sync point supported. */60unsigned int host1x_syncpt_nb_pts(struct host1x *host);61 62/* Return number of wait bases supported. */63unsigned int host1x_syncpt_nb_bases(struct host1x *host);64 65/* Return number of mlocks supported. */66unsigned int host1x_syncpt_nb_mlocks(struct host1x *host);67 68/*69 * Check sync point sanity. If max is larger than min, there have too many70 * sync point increments.71 *72 * Client managed sync point are not tracked.73 * */74static inline bool host1x_syncpt_check_max(struct host1x_syncpt *sp, u32 real)75{76 u32 max;77 if (sp->client_managed)78 return true;79 max = host1x_syncpt_read_max(sp);80 return (s32)(max - real) >= 0;81}82 83/* Return true if sync point is client managed. */84static inline bool host1x_syncpt_client_managed(struct host1x_syncpt *sp)85{86 return sp->client_managed;87}88 89/*90 * Returns true if syncpoint min == max, which means that there are no91 * outstanding operations.92 */93static inline bool host1x_syncpt_idle(struct host1x_syncpt *sp)94{95 int min, max;96 smp_rmb();97 min = atomic_read(&sp->min_val);98 max = atomic_read(&sp->max_val);99 return (min == max);100}101 102/* Load current value from hardware to the shadow register. */103u32 host1x_syncpt_load(struct host1x_syncpt *sp);104 105/* Check if the given syncpoint value has already passed */106bool host1x_syncpt_is_expired(struct host1x_syncpt *sp, u32 thresh);107 108/* Save host1x sync point state into shadow registers. */109void host1x_syncpt_save(struct host1x *host);110 111/* Reset host1x sync point state from shadow registers. */112void host1x_syncpt_restore(struct host1x *host);113 114/* Read current wait base value into shadow register and return it. */115u32 host1x_syncpt_load_wait_base(struct host1x_syncpt *sp);116 117/* Indicate future operations by incrementing the sync point max. */118u32 host1x_syncpt_incr_max(struct host1x_syncpt *sp, u32 incrs);119 120/* Check if sync point id is valid. */121static inline int host1x_syncpt_is_valid(struct host1x_syncpt *sp)122{123 return sp->id < host1x_syncpt_nb_pts(sp->host);124}125 126static inline void host1x_syncpt_set_locked(struct host1x_syncpt *sp)127{128 sp->locked = true;129}130 131#endif132