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