video: tegra: refactor for multiple chip support
[linux-2.6.git] / drivers / video / tegra / host / nvhost_syncpt.h
1 /*
2  * drivers/video/tegra/host/nvhost_syncpt.h
3  *
4  * Tegra Graphics Host Syncpoints
5  *
6  * Copyright (c) 2010, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 #ifndef __NVHOST_SYNCPT_H
24 #define __NVHOST_SYNCPT_H
25
26 #include <linux/kernel.h>
27 #include <linux/sched.h>
28 #include <mach/nvhost.h>
29 #include <mach/nvmap.h>
30 #include <asm/atomic.h>
31
32 /* host managed and invalid syncpt id */
33 #define NVSYNCPT_GRAPHICS_HOST               (0)
34 #define NVSYNCPT_INVALID                     (-1)
35
36 struct nvhost_syncpt {
37         atomic_t *min_val;
38         atomic_t *max_val;
39         u32 *base_val;
40         u32 nb_pts;
41         u32 nb_bases;
42         u32 client_managed;
43 };
44
45 int nvhost_syncpt_init(struct nvhost_syncpt *);
46 #define client_managed(id) (BIT(id) & sp->client_managed)
47 #define syncpt_to_dev(sp) container_of(sp, struct nvhost_master, syncpt)
48 #define syncpt_op(sp) (syncpt_to_dev(sp)->op.syncpt)
49 #define SYNCPT_CHECK_PERIOD 2*HZ
50 static inline bool nvhost_syncpt_check_max(struct nvhost_syncpt *sp, u32 id, u32 real)
51 {
52         u32 max;
53         if (client_managed(id))
54                 return true;
55         smp_rmb();
56         max = (u32)atomic_read(&sp->max_val[id]);
57         return ((s32)(max - real) >= 0);
58 }
59
60
61 /**
62  * Updates the value sent to hardware.
63  */
64 static inline u32 nvhost_syncpt_incr_max(struct nvhost_syncpt *sp,
65                                         u32 id, u32 incrs)
66 {
67         return (u32)atomic_add_return(incrs, &sp->max_val[id]);
68 }
69
70 /**
71  * Updated the value sent to hardware.
72  */
73 static inline u32 nvhost_syncpt_set_max(struct nvhost_syncpt *sp,
74                                         u32 id, u32 val)
75 {
76         atomic_set(&sp->max_val[id], val);
77         smp_wmb();
78         return val;
79 }
80
81 static inline u32 nvhost_syncpt_read_max(struct nvhost_syncpt *sp, u32 id)
82 {
83         smp_rmb();
84         return (u32)atomic_read(&sp->max_val[id]);
85 }
86
87 static inline u32 nvhost_syncpt_read_min(struct nvhost_syncpt *sp, u32 id)
88 {
89         smp_rmb();
90         return (u32)atomic_read(&sp->min_val[id]);
91 }
92
93 /**
94  * Returns true if syncpoint has reached threshold
95  */
96 static inline bool nvhost_syncpt_min_cmp(struct nvhost_syncpt *sp,
97                                         u32 id, u32 thresh)
98 {
99         u32 cur;
100         smp_rmb();
101         cur = (u32)atomic_read(&sp->min_val[id]);
102         return ((s32)(cur - thresh) >= 0);
103 }
104
105 /**
106  * Returns true if syncpoint min == max
107  */
108 static inline bool nvhost_syncpt_min_eq_max(struct nvhost_syncpt *sp, u32 id)
109 {
110         int min, max;
111         smp_rmb();
112         min = atomic_read(&sp->min_val[id]);
113         max = atomic_read(&sp->max_val[id]);
114         return (min == max);
115 }
116
117 void nvhost_syncpt_cpu_incr(struct nvhost_syncpt *sp, u32 id);
118
119 u32 nvhost_syncpt_update_min(struct nvhost_syncpt *sp, u32 id);
120
121 void nvhost_syncpt_save(struct nvhost_syncpt *sp);
122
123 void nvhost_syncpt_reset(struct nvhost_syncpt *sp);
124
125 u32 nvhost_syncpt_read(struct nvhost_syncpt *sp, u32 id);
126
127 void nvhost_syncpt_incr(struct nvhost_syncpt *sp, u32 id);
128
129 int nvhost_syncpt_wait_timeout(struct nvhost_syncpt *sp, u32 id, u32 thresh,
130                         u32 timeout, u32 *value);
131
132 static inline int nvhost_syncpt_wait(struct nvhost_syncpt *sp, u32 id, u32 thresh)
133 {
134         return nvhost_syncpt_wait_timeout(sp, id, thresh,
135                                           MAX_SCHEDULE_TIMEOUT, NULL);
136 }
137
138 /*
139  * Check driver supplied waitchk structs for syncpt thresholds
140  * that have already been satisfied and NULL the comparison (to
141  * avoid a wrap condition in the HW).
142  *
143  * @param: sp - global shadowed syncpt struct
144  * @param: nvmap - needed to access command buffer
145  * @param: mask - bit mask of syncpt IDs referenced in WAITs
146  * @param: wait - start of filled in array of waitchk structs
147  * @param: waitend - end ptr (one beyond last valid waitchk)
148  */
149 int nvhost_syncpt_wait_check(struct nvhost_syncpt *sp,
150                         struct nvmap_client *nvmap,
151                         u32 mask,
152                         struct nvhost_waitchk *wait,
153                         struct nvhost_waitchk *waitend);
154
155 const char *nvhost_syncpt_name(u32 id);
156
157 void nvhost_syncpt_debug(struct nvhost_syncpt *sp);
158
159 #endif