Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Tegra host1x Syncpoints |
| 3 | * |
| 4 | * Copyright (c) 2010-2013, NVIDIA Corporation. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms and conditions of the GNU General Public License, |
| 8 | * version 2, as published by the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope it will be useful, but WITHOUT |
| 11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 13 | * more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License |
| 16 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 17 | */ |
| 18 | |
| 19 | #include <linux/module.h> |
| 20 | #include <linux/device.h> |
| 21 | #include <linux/slab.h> |
| 22 | |
| 23 | #include <trace/events/host1x.h> |
| 24 | |
| 25 | #include "syncpt.h" |
| 26 | #include "dev.h" |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 27 | #include "intr.h" |
Terje Bergstrom | 6236451 | 2013-03-22 16:34:04 +0200 | [diff] [blame] | 28 | #include "debug.h" |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 29 | |
| 30 | #define SYNCPT_CHECK_PERIOD (2 * HZ) |
| 31 | #define MAX_STUCK_CHECK_COUNT 15 |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 32 | |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 33 | static struct host1x_syncpt_base * |
| 34 | host1x_syncpt_base_request(struct host1x *host) |
| 35 | { |
| 36 | struct host1x_syncpt_base *bases = host->bases; |
| 37 | unsigned int i; |
| 38 | |
| 39 | for (i = 0; i < host->info->nb_bases; i++) |
| 40 | if (!bases[i].requested) |
| 41 | break; |
| 42 | |
| 43 | if (i >= host->info->nb_bases) |
| 44 | return NULL; |
| 45 | |
| 46 | bases[i].requested = true; |
| 47 | return &bases[i]; |
| 48 | } |
| 49 | |
| 50 | static void host1x_syncpt_base_free(struct host1x_syncpt_base *base) |
| 51 | { |
| 52 | if (base) |
| 53 | base->requested = false; |
| 54 | } |
| 55 | |
Arto Merilainen | 8736fe8 | 2013-10-14 15:21:52 +0300 | [diff] [blame] | 56 | static struct host1x_syncpt *host1x_syncpt_alloc(struct host1x *host, |
| 57 | struct device *dev, |
| 58 | unsigned long flags) |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 59 | { |
| 60 | int i; |
| 61 | struct host1x_syncpt *sp = host->syncpt; |
| 62 | char *name; |
| 63 | |
| 64 | for (i = 0; i < host->info->nb_pts && sp->name; i++, sp++) |
| 65 | ; |
Arto Merilainen | edeabfc | 2013-05-29 13:26:06 +0300 | [diff] [blame] | 66 | |
| 67 | if (i >= host->info->nb_pts) |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 68 | return NULL; |
| 69 | |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 70 | if (flags & HOST1X_SYNCPT_HAS_BASE) { |
| 71 | sp->base = host1x_syncpt_base_request(host); |
| 72 | if (!sp->base) |
| 73 | return NULL; |
| 74 | } |
| 75 | |
Thierry Reding | 5c0d8d3 | 2016-06-23 11:19:00 +0200 | [diff] [blame] | 76 | name = kasprintf(GFP_KERNEL, "%02u-%s", sp->id, |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 77 | dev ? dev_name(dev) : NULL); |
| 78 | if (!name) |
| 79 | return NULL; |
| 80 | |
| 81 | sp->dev = dev; |
| 82 | sp->name = name; |
Arto Merilainen | 8736fe8 | 2013-10-14 15:21:52 +0300 | [diff] [blame] | 83 | |
| 84 | if (flags & HOST1X_SYNCPT_CLIENT_MANAGED) |
| 85 | sp->client_managed = true; |
| 86 | else |
| 87 | sp->client_managed = false; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 88 | |
| 89 | return sp; |
| 90 | } |
| 91 | |
| 92 | u32 host1x_syncpt_id(struct host1x_syncpt *sp) |
| 93 | { |
| 94 | return sp->id; |
| 95 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 96 | EXPORT_SYMBOL(host1x_syncpt_id); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 97 | |
| 98 | /* |
| 99 | * Updates the value sent to hardware. |
| 100 | */ |
| 101 | u32 host1x_syncpt_incr_max(struct host1x_syncpt *sp, u32 incrs) |
| 102 | { |
| 103 | return (u32)atomic_add_return(incrs, &sp->max_val); |
| 104 | } |
Bryan Wu | 64400c3 | 2014-02-19 14:48:36 -0800 | [diff] [blame] | 105 | EXPORT_SYMBOL(host1x_syncpt_incr_max); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 106 | |
| 107 | /* |
| 108 | * Write cached syncpoint and waitbase values to hardware. |
| 109 | */ |
| 110 | void host1x_syncpt_restore(struct host1x *host) |
| 111 | { |
| 112 | struct host1x_syncpt *sp_base = host->syncpt; |
Thierry Reding | 14c95fc | 2016-06-22 16:44:07 +0200 | [diff] [blame] | 113 | unsigned int i; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 114 | |
| 115 | for (i = 0; i < host1x_syncpt_nb_pts(host); i++) |
| 116 | host1x_hw_syncpt_restore(host, sp_base + i); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 117 | |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 118 | for (i = 0; i < host1x_syncpt_nb_bases(host); i++) |
| 119 | host1x_hw_syncpt_restore_wait_base(host, sp_base + i); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 120 | |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 121 | wmb(); |
| 122 | } |
| 123 | |
| 124 | /* |
| 125 | * Update the cached syncpoint and waitbase values by reading them |
| 126 | * from the registers. |
| 127 | */ |
| 128 | void host1x_syncpt_save(struct host1x *host) |
| 129 | { |
| 130 | struct host1x_syncpt *sp_base = host->syncpt; |
Thierry Reding | 14c95fc | 2016-06-22 16:44:07 +0200 | [diff] [blame] | 131 | unsigned int i; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 132 | |
| 133 | for (i = 0; i < host1x_syncpt_nb_pts(host); i++) { |
| 134 | if (host1x_syncpt_client_managed(sp_base + i)) |
| 135 | host1x_hw_syncpt_load(host, sp_base + i); |
| 136 | else |
| 137 | WARN_ON(!host1x_syncpt_idle(sp_base + i)); |
| 138 | } |
| 139 | |
| 140 | for (i = 0; i < host1x_syncpt_nb_bases(host); i++) |
| 141 | host1x_hw_syncpt_load_wait_base(host, sp_base + i); |
| 142 | } |
| 143 | |
| 144 | /* |
| 145 | * Updates the cached syncpoint value by reading a new value from the hardware |
| 146 | * register |
| 147 | */ |
| 148 | u32 host1x_syncpt_load(struct host1x_syncpt *sp) |
| 149 | { |
| 150 | u32 val; |
Thierry Reding | 6df633d | 2016-06-23 11:33:31 +0200 | [diff] [blame] | 151 | |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 152 | val = host1x_hw_syncpt_load(sp->host, sp); |
| 153 | trace_host1x_syncpt_load_min(sp->id, val); |
| 154 | |
| 155 | return val; |
| 156 | } |
| 157 | |
| 158 | /* |
| 159 | * Get the current syncpoint base |
| 160 | */ |
| 161 | u32 host1x_syncpt_load_wait_base(struct host1x_syncpt *sp) |
| 162 | { |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 163 | host1x_hw_syncpt_load_wait_base(sp->host, sp); |
Thierry Reding | 4b92e29 | 2016-06-23 11:39:11 +0200 | [diff] [blame^] | 164 | |
| 165 | return sp->base_val; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 166 | } |
| 167 | |
| 168 | /* |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 169 | * Increment syncpoint value from cpu, updating cache |
| 170 | */ |
Arto Merilainen | ebae30b | 2013-05-29 13:26:08 +0300 | [diff] [blame] | 171 | int host1x_syncpt_incr(struct host1x_syncpt *sp) |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 172 | { |
Arto Merilainen | ebae30b | 2013-05-29 13:26:08 +0300 | [diff] [blame] | 173 | return host1x_hw_syncpt_cpu_incr(sp->host, sp); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 174 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 175 | EXPORT_SYMBOL(host1x_syncpt_incr); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 176 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 177 | /* |
| 178 | * Updated sync point form hardware, and returns true if syncpoint is expired, |
| 179 | * false if we may need to wait |
| 180 | */ |
| 181 | static bool syncpt_load_min_is_expired(struct host1x_syncpt *sp, u32 thresh) |
| 182 | { |
| 183 | host1x_hw_syncpt_load(sp->host, sp); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 184 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 185 | return host1x_syncpt_is_expired(sp, thresh); |
| 186 | } |
| 187 | |
| 188 | /* |
| 189 | * Main entrypoint for syncpoint value waits. |
| 190 | */ |
| 191 | int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout, |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 192 | u32 *value) |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 193 | { |
| 194 | DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); |
| 195 | void *ref; |
| 196 | struct host1x_waitlist *waiter; |
| 197 | int err = 0, check_count = 0; |
| 198 | u32 val; |
| 199 | |
| 200 | if (value) |
| 201 | *value = 0; |
| 202 | |
| 203 | /* first check cache */ |
| 204 | if (host1x_syncpt_is_expired(sp, thresh)) { |
| 205 | if (value) |
| 206 | *value = host1x_syncpt_load(sp); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 207 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 208 | return 0; |
| 209 | } |
| 210 | |
| 211 | /* try to read from register */ |
| 212 | val = host1x_hw_syncpt_load(sp->host, sp); |
| 213 | if (host1x_syncpt_is_expired(sp, thresh)) { |
| 214 | if (value) |
| 215 | *value = val; |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 216 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 217 | goto done; |
| 218 | } |
| 219 | |
| 220 | if (!timeout) { |
| 221 | err = -EAGAIN; |
| 222 | goto done; |
| 223 | } |
| 224 | |
| 225 | /* allocate a waiter */ |
| 226 | waiter = kzalloc(sizeof(*waiter), GFP_KERNEL); |
| 227 | if (!waiter) { |
| 228 | err = -ENOMEM; |
| 229 | goto done; |
| 230 | } |
| 231 | |
| 232 | /* schedule a wakeup when the syncpoint value is reached */ |
| 233 | err = host1x_intr_add_action(sp->host, sp->id, thresh, |
| 234 | HOST1X_INTR_ACTION_WAKEUP_INTERRUPTIBLE, |
| 235 | &wq, waiter, &ref); |
| 236 | if (err) |
| 237 | goto done; |
| 238 | |
| 239 | err = -EAGAIN; |
| 240 | /* Caller-specified timeout may be impractically low */ |
| 241 | if (timeout < 0) |
| 242 | timeout = LONG_MAX; |
| 243 | |
| 244 | /* wait for the syncpoint, or timeout, or signal */ |
| 245 | while (timeout) { |
| 246 | long check = min_t(long, SYNCPT_CHECK_PERIOD, timeout); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 247 | int remain; |
| 248 | |
| 249 | remain = wait_event_interruptible_timeout(wq, |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 250 | syncpt_load_min_is_expired(sp, thresh), |
| 251 | check); |
| 252 | if (remain > 0 || host1x_syncpt_is_expired(sp, thresh)) { |
| 253 | if (value) |
| 254 | *value = host1x_syncpt_load(sp); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 255 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 256 | err = 0; |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 257 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 258 | break; |
| 259 | } |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 260 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 261 | if (remain < 0) { |
| 262 | err = remain; |
| 263 | break; |
| 264 | } |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 265 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 266 | timeout -= check; |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 267 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 268 | if (timeout && check_count <= MAX_STUCK_CHECK_COUNT) { |
| 269 | dev_warn(sp->host->dev, |
Thierry Reding | 5c0d8d3 | 2016-06-23 11:19:00 +0200 | [diff] [blame] | 270 | "%s: syncpoint id %u (%s) stuck waiting %d, timeout=%ld\n", |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 271 | current->comm, sp->id, sp->name, |
| 272 | thresh, timeout); |
Terje Bergstrom | 6236451 | 2013-03-22 16:34:04 +0200 | [diff] [blame] | 273 | |
| 274 | host1x_debug_dump_syncpts(sp->host); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 275 | |
Terje Bergstrom | 6236451 | 2013-03-22 16:34:04 +0200 | [diff] [blame] | 276 | if (check_count == MAX_STUCK_CHECK_COUNT) |
| 277 | host1x_debug_dump(sp->host); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 278 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 279 | check_count++; |
| 280 | } |
| 281 | } |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 282 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 283 | host1x_intr_put_ref(sp->host, sp->id, ref); |
| 284 | |
| 285 | done: |
| 286 | return err; |
| 287 | } |
| 288 | EXPORT_SYMBOL(host1x_syncpt_wait); |
| 289 | |
| 290 | /* |
| 291 | * Returns true if syncpoint is expired, false if we may need to wait |
| 292 | */ |
| 293 | bool host1x_syncpt_is_expired(struct host1x_syncpt *sp, u32 thresh) |
| 294 | { |
| 295 | u32 current_val; |
| 296 | u32 future_val; |
Thierry Reding | 6df633d | 2016-06-23 11:33:31 +0200 | [diff] [blame] | 297 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 298 | smp_rmb(); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 299 | |
Terje Bergstrom | 7ede0b0 | 2013-03-22 16:34:02 +0200 | [diff] [blame] | 300 | current_val = (u32)atomic_read(&sp->min_val); |
| 301 | future_val = (u32)atomic_read(&sp->max_val); |
| 302 | |
| 303 | /* Note the use of unsigned arithmetic here (mod 1<<32). |
| 304 | * |
| 305 | * c = current_val = min_val = the current value of the syncpoint. |
| 306 | * t = thresh = the value we are checking |
| 307 | * f = future_val = max_val = the value c will reach when all |
| 308 | * outstanding increments have completed. |
| 309 | * |
| 310 | * Note that c always chases f until it reaches f. |
| 311 | * |
| 312 | * Dtf = (f - t) |
| 313 | * Dtc = (c - t) |
| 314 | * |
| 315 | * Consider all cases: |
| 316 | * |
| 317 | * A) .....c..t..f..... Dtf < Dtc need to wait |
| 318 | * B) .....c.....f..t.. Dtf > Dtc expired |
| 319 | * C) ..t..c.....f..... Dtf > Dtc expired (Dct very large) |
| 320 | * |
| 321 | * Any case where f==c: always expired (for any t). Dtf == Dcf |
| 322 | * Any case where t==c: always expired (for any f). Dtf >= Dtc (because Dtc==0) |
| 323 | * Any case where t==f!=c: always wait. Dtf < Dtc (because Dtf==0, |
| 324 | * Dtc!=0) |
| 325 | * |
| 326 | * Other cases: |
| 327 | * |
| 328 | * A) .....t..f..c..... Dtf < Dtc need to wait |
| 329 | * A) .....f..c..t..... Dtf < Dtc need to wait |
| 330 | * A) .....f..t..c..... Dtf > Dtc expired |
| 331 | * |
| 332 | * So: |
| 333 | * Dtf >= Dtc implies EXPIRED (return true) |
| 334 | * Dtf < Dtc implies WAIT (return false) |
| 335 | * |
| 336 | * Note: If t is expired then we *cannot* wait on it. We would wait |
| 337 | * forever (hang the system). |
| 338 | * |
| 339 | * Note: do NOT get clever and remove the -thresh from both sides. It |
| 340 | * is NOT the same. |
| 341 | * |
| 342 | * If future valueis zero, we have a client managed sync point. In that |
| 343 | * case we do a direct comparison. |
| 344 | */ |
| 345 | if (!host1x_syncpt_client_managed(sp)) |
| 346 | return future_val - thresh >= current_val - thresh; |
| 347 | else |
| 348 | return (s32)(current_val - thresh) >= 0; |
| 349 | } |
| 350 | |
Terje Bergstrom | 6579324 | 2013-03-22 16:34:03 +0200 | [diff] [blame] | 351 | /* remove a wait pointed to by patch_addr */ |
| 352 | int host1x_syncpt_patch_wait(struct host1x_syncpt *sp, void *patch_addr) |
| 353 | { |
| 354 | return host1x_hw_syncpt_patch_wait(sp->host, sp, patch_addr); |
| 355 | } |
| 356 | |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 357 | int host1x_syncpt_init(struct host1x *host) |
| 358 | { |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 359 | struct host1x_syncpt_base *bases; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 360 | struct host1x_syncpt *syncpt; |
Thierry Reding | 14c95fc | 2016-06-22 16:44:07 +0200 | [diff] [blame] | 361 | unsigned int i; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 362 | |
Thierry Reding | b47a049 | 2016-06-23 11:24:59 +0200 | [diff] [blame] | 363 | syncpt = devm_kcalloc(host->dev, host->info->nb_pts, sizeof(*syncpt), |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 364 | GFP_KERNEL); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 365 | if (!syncpt) |
| 366 | return -ENOMEM; |
| 367 | |
Thierry Reding | b47a049 | 2016-06-23 11:24:59 +0200 | [diff] [blame] | 368 | bases = devm_kcalloc(host->dev, host->info->nb_bases, sizeof(*bases), |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 369 | GFP_KERNEL); |
| 370 | if (!bases) |
| 371 | return -ENOMEM; |
| 372 | |
| 373 | for (i = 0; i < host->info->nb_pts; i++) { |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 374 | syncpt[i].id = i; |
| 375 | syncpt[i].host = host; |
| 376 | } |
| 377 | |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 378 | for (i = 0; i < host->info->nb_bases; i++) |
| 379 | bases[i].id = i; |
| 380 | |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 381 | host->syncpt = syncpt; |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 382 | host->bases = bases; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 383 | |
| 384 | host1x_syncpt_restore(host); |
| 385 | |
Terje Bergstrom | 6579324 | 2013-03-22 16:34:03 +0200 | [diff] [blame] | 386 | /* Allocate sync point to use for clearing waits for expired fences */ |
Arto Merilainen | 8736fe8 | 2013-10-14 15:21:52 +0300 | [diff] [blame] | 387 | host->nop_sp = host1x_syncpt_alloc(host, NULL, 0); |
Terje Bergstrom | 6579324 | 2013-03-22 16:34:03 +0200 | [diff] [blame] | 388 | if (!host->nop_sp) |
| 389 | return -ENOMEM; |
| 390 | |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 391 | return 0; |
| 392 | } |
| 393 | |
| 394 | struct host1x_syncpt *host1x_syncpt_request(struct device *dev, |
Arto Merilainen | 8736fe8 | 2013-10-14 15:21:52 +0300 | [diff] [blame] | 395 | unsigned long flags) |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 396 | { |
| 397 | struct host1x *host = dev_get_drvdata(dev->parent); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 398 | |
Arto Merilainen | 8736fe8 | 2013-10-14 15:21:52 +0300 | [diff] [blame] | 399 | return host1x_syncpt_alloc(host, dev, flags); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 400 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 401 | EXPORT_SYMBOL(host1x_syncpt_request); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 402 | |
| 403 | void host1x_syncpt_free(struct host1x_syncpt *sp) |
| 404 | { |
| 405 | if (!sp) |
| 406 | return; |
| 407 | |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 408 | host1x_syncpt_base_free(sp->base); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 409 | kfree(sp->name); |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 410 | sp->base = NULL; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 411 | sp->dev = NULL; |
| 412 | sp->name = NULL; |
Arto Merilainen | ece6689 | 2013-05-29 13:26:07 +0300 | [diff] [blame] | 413 | sp->client_managed = false; |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 414 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 415 | EXPORT_SYMBOL(host1x_syncpt_free); |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 416 | |
| 417 | void host1x_syncpt_deinit(struct host1x *host) |
| 418 | { |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 419 | struct host1x_syncpt *sp = host->syncpt; |
Thierry Reding | 14c95fc | 2016-06-22 16:44:07 +0200 | [diff] [blame] | 420 | unsigned int i; |
| 421 | |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 422 | for (i = 0; i < host->info->nb_pts; i++, sp++) |
| 423 | kfree(sp->name); |
| 424 | } |
| 425 | |
Thierry Reding | 35d747a | 2013-09-24 16:30:32 +0200 | [diff] [blame] | 426 | /* |
| 427 | * Read max. It indicates how many operations there are in queue, either in |
| 428 | * channel or in a software thread. |
Thierry Reding | 6df633d | 2016-06-23 11:33:31 +0200 | [diff] [blame] | 429 | */ |
Thierry Reding | 35d747a | 2013-09-24 16:30:32 +0200 | [diff] [blame] | 430 | u32 host1x_syncpt_read_max(struct host1x_syncpt *sp) |
| 431 | { |
| 432 | smp_rmb(); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 433 | |
Thierry Reding | 35d747a | 2013-09-24 16:30:32 +0200 | [diff] [blame] | 434 | return (u32)atomic_read(&sp->max_val); |
| 435 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 436 | EXPORT_SYMBOL(host1x_syncpt_read_max); |
Thierry Reding | 35d747a | 2013-09-24 16:30:32 +0200 | [diff] [blame] | 437 | |
| 438 | /* |
| 439 | * Read min, which is a shadow of the current sync point value in hardware. |
| 440 | */ |
| 441 | u32 host1x_syncpt_read_min(struct host1x_syncpt *sp) |
| 442 | { |
| 443 | smp_rmb(); |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 444 | |
Thierry Reding | 35d747a | 2013-09-24 16:30:32 +0200 | [diff] [blame] | 445 | return (u32)atomic_read(&sp->min_val); |
| 446 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 447 | EXPORT_SYMBOL(host1x_syncpt_read_min); |
Thierry Reding | 35d747a | 2013-09-24 16:30:32 +0200 | [diff] [blame] | 448 | |
Thierry Reding | b4a20144 | 2015-01-28 14:29:02 +0100 | [diff] [blame] | 449 | u32 host1x_syncpt_read(struct host1x_syncpt *sp) |
| 450 | { |
| 451 | return host1x_syncpt_load(sp); |
| 452 | } |
| 453 | EXPORT_SYMBOL(host1x_syncpt_read); |
| 454 | |
Thierry Reding | 14c95fc | 2016-06-22 16:44:07 +0200 | [diff] [blame] | 455 | unsigned int host1x_syncpt_nb_pts(struct host1x *host) |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 456 | { |
| 457 | return host->info->nb_pts; |
| 458 | } |
| 459 | |
Thierry Reding | 14c95fc | 2016-06-22 16:44:07 +0200 | [diff] [blame] | 460 | unsigned int host1x_syncpt_nb_bases(struct host1x *host) |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 461 | { |
| 462 | return host->info->nb_bases; |
| 463 | } |
| 464 | |
Thierry Reding | 14c95fc | 2016-06-22 16:44:07 +0200 | [diff] [blame] | 465 | unsigned int host1x_syncpt_nb_mlocks(struct host1x *host) |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 466 | { |
| 467 | return host->info->nb_mlocks; |
| 468 | } |
| 469 | |
Thierry Reding | 5c0d8d3 | 2016-06-23 11:19:00 +0200 | [diff] [blame] | 470 | struct host1x_syncpt *host1x_syncpt_get(struct host1x *host, unsigned int id) |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 471 | { |
| 472 | if (host->info->nb_pts < id) |
| 473 | return NULL; |
Thierry Reding | 0b8070d1 | 2016-06-23 11:35:50 +0200 | [diff] [blame] | 474 | |
Terje Bergstrom | 7547168 | 2013-03-22 16:34:01 +0200 | [diff] [blame] | 475 | return host->syncpt + id; |
| 476 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 477 | EXPORT_SYMBOL(host1x_syncpt_get); |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 478 | |
| 479 | struct host1x_syncpt_base *host1x_syncpt_get_base(struct host1x_syncpt *sp) |
| 480 | { |
| 481 | return sp ? sp->base : NULL; |
| 482 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 483 | EXPORT_SYMBOL(host1x_syncpt_get_base); |
Arto Merilainen | f5a954f | 2013-10-14 15:21:53 +0300 | [diff] [blame] | 484 | |
| 485 | u32 host1x_syncpt_base_id(struct host1x_syncpt_base *base) |
| 486 | { |
| 487 | return base->id; |
| 488 | } |
Thierry Reding | fae798a | 2013-11-08 11:41:42 +0100 | [diff] [blame] | 489 | EXPORT_SYMBOL(host1x_syncpt_base_id); |