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" 27 #include "intr.h" 28 #include "debug.h" 29 30 #define SYNCPT_CHECK_PERIOD (2 * HZ) 31 #define MAX_STUCK_CHECK_COUNT 15 32 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 56 static struct host1x_syncpt *host1x_syncpt_alloc(struct host1x *host, 57 struct device *dev, 58 unsigned long flags) 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 ; 66 67 if (i >= host->info->nb_pts) 68 return NULL; 69 70 if (flags & HOST1X_SYNCPT_HAS_BASE) { 71 sp->base = host1x_syncpt_base_request(host); 72 if (!sp->base) 73 return NULL; 74 } 75 76 name = kasprintf(GFP_KERNEL, "%02d-%s", sp->id, 77 dev ? dev_name(dev) : NULL); 78 if (!name) 79 return NULL; 80 81 sp->dev = dev; 82 sp->name = name; 83 84 if (flags & HOST1X_SYNCPT_CLIENT_MANAGED) 85 sp->client_managed = true; 86 else 87 sp->client_managed = false; 88 89 return sp; 90 } 91 92 u32 host1x_syncpt_id(struct host1x_syncpt *sp) 93 { 94 return sp->id; 95 } 96 97 /* 98 * Updates the value sent to hardware. 99 */ 100 u32 host1x_syncpt_incr_max(struct host1x_syncpt *sp, u32 incrs) 101 { 102 return (u32)atomic_add_return(incrs, &sp->max_val); 103 } 104 105 /* 106 * Write cached syncpoint and waitbase values to hardware. 107 */ 108 void host1x_syncpt_restore(struct host1x *host) 109 { 110 struct host1x_syncpt *sp_base = host->syncpt; 111 u32 i; 112 113 for (i = 0; i < host1x_syncpt_nb_pts(host); i++) 114 host1x_hw_syncpt_restore(host, sp_base + i); 115 for (i = 0; i < host1x_syncpt_nb_bases(host); i++) 116 host1x_hw_syncpt_restore_wait_base(host, sp_base + i); 117 wmb(); 118 } 119 120 /* 121 * Update the cached syncpoint and waitbase values by reading them 122 * from the registers. 123 */ 124 void host1x_syncpt_save(struct host1x *host) 125 { 126 struct host1x_syncpt *sp_base = host->syncpt; 127 u32 i; 128 129 for (i = 0; i < host1x_syncpt_nb_pts(host); i++) { 130 if (host1x_syncpt_client_managed(sp_base + i)) 131 host1x_hw_syncpt_load(host, sp_base + i); 132 else 133 WARN_ON(!host1x_syncpt_idle(sp_base + i)); 134 } 135 136 for (i = 0; i < host1x_syncpt_nb_bases(host); i++) 137 host1x_hw_syncpt_load_wait_base(host, sp_base + i); 138 } 139 140 /* 141 * Updates the cached syncpoint value by reading a new value from the hardware 142 * register 143 */ 144 u32 host1x_syncpt_load(struct host1x_syncpt *sp) 145 { 146 u32 val; 147 val = host1x_hw_syncpt_load(sp->host, sp); 148 trace_host1x_syncpt_load_min(sp->id, val); 149 150 return val; 151 } 152 153 /* 154 * Get the current syncpoint base 155 */ 156 u32 host1x_syncpt_load_wait_base(struct host1x_syncpt *sp) 157 { 158 u32 val; 159 host1x_hw_syncpt_load_wait_base(sp->host, sp); 160 val = sp->base_val; 161 return val; 162 } 163 164 /* 165 * Increment syncpoint value from cpu, updating cache 166 */ 167 int host1x_syncpt_incr(struct host1x_syncpt *sp) 168 { 169 return host1x_hw_syncpt_cpu_incr(sp->host, sp); 170 } 171 172 /* 173 * Updated sync point form hardware, and returns true if syncpoint is expired, 174 * false if we may need to wait 175 */ 176 static bool syncpt_load_min_is_expired(struct host1x_syncpt *sp, u32 thresh) 177 { 178 host1x_hw_syncpt_load(sp->host, sp); 179 return host1x_syncpt_is_expired(sp, thresh); 180 } 181 182 /* 183 * Main entrypoint for syncpoint value waits. 184 */ 185 int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout, 186 u32 *value) 187 { 188 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 189 void *ref; 190 struct host1x_waitlist *waiter; 191 int err = 0, check_count = 0; 192 u32 val; 193 194 if (value) 195 *value = 0; 196 197 /* first check cache */ 198 if (host1x_syncpt_is_expired(sp, thresh)) { 199 if (value) 200 *value = host1x_syncpt_load(sp); 201 return 0; 202 } 203 204 /* try to read from register */ 205 val = host1x_hw_syncpt_load(sp->host, sp); 206 if (host1x_syncpt_is_expired(sp, thresh)) { 207 if (value) 208 *value = val; 209 goto done; 210 } 211 212 if (!timeout) { 213 err = -EAGAIN; 214 goto done; 215 } 216 217 /* allocate a waiter */ 218 waiter = kzalloc(sizeof(*waiter), GFP_KERNEL); 219 if (!waiter) { 220 err = -ENOMEM; 221 goto done; 222 } 223 224 /* schedule a wakeup when the syncpoint value is reached */ 225 err = host1x_intr_add_action(sp->host, sp->id, thresh, 226 HOST1X_INTR_ACTION_WAKEUP_INTERRUPTIBLE, 227 &wq, waiter, &ref); 228 if (err) 229 goto done; 230 231 err = -EAGAIN; 232 /* Caller-specified timeout may be impractically low */ 233 if (timeout < 0) 234 timeout = LONG_MAX; 235 236 /* wait for the syncpoint, or timeout, or signal */ 237 while (timeout) { 238 long check = min_t(long, SYNCPT_CHECK_PERIOD, timeout); 239 int remain = wait_event_interruptible_timeout(wq, 240 syncpt_load_min_is_expired(sp, thresh), 241 check); 242 if (remain > 0 || host1x_syncpt_is_expired(sp, thresh)) { 243 if (value) 244 *value = host1x_syncpt_load(sp); 245 err = 0; 246 break; 247 } 248 if (remain < 0) { 249 err = remain; 250 break; 251 } 252 timeout -= check; 253 if (timeout && check_count <= MAX_STUCK_CHECK_COUNT) { 254 dev_warn(sp->host->dev, 255 "%s: syncpoint id %d (%s) stuck waiting %d, timeout=%ld\n", 256 current->comm, sp->id, sp->name, 257 thresh, timeout); 258 259 host1x_debug_dump_syncpts(sp->host); 260 if (check_count == MAX_STUCK_CHECK_COUNT) 261 host1x_debug_dump(sp->host); 262 check_count++; 263 } 264 } 265 host1x_intr_put_ref(sp->host, sp->id, ref); 266 267 done: 268 return err; 269 } 270 EXPORT_SYMBOL(host1x_syncpt_wait); 271 272 /* 273 * Returns true if syncpoint is expired, false if we may need to wait 274 */ 275 bool host1x_syncpt_is_expired(struct host1x_syncpt *sp, u32 thresh) 276 { 277 u32 current_val; 278 u32 future_val; 279 smp_rmb(); 280 current_val = (u32)atomic_read(&sp->min_val); 281 future_val = (u32)atomic_read(&sp->max_val); 282 283 /* Note the use of unsigned arithmetic here (mod 1<<32). 284 * 285 * c = current_val = min_val = the current value of the syncpoint. 286 * t = thresh = the value we are checking 287 * f = future_val = max_val = the value c will reach when all 288 * outstanding increments have completed. 289 * 290 * Note that c always chases f until it reaches f. 291 * 292 * Dtf = (f - t) 293 * Dtc = (c - t) 294 * 295 * Consider all cases: 296 * 297 * A) .....c..t..f..... Dtf < Dtc need to wait 298 * B) .....c.....f..t.. Dtf > Dtc expired 299 * C) ..t..c.....f..... Dtf > Dtc expired (Dct very large) 300 * 301 * Any case where f==c: always expired (for any t). Dtf == Dcf 302 * Any case where t==c: always expired (for any f). Dtf >= Dtc (because Dtc==0) 303 * Any case where t==f!=c: always wait. Dtf < Dtc (because Dtf==0, 304 * Dtc!=0) 305 * 306 * Other cases: 307 * 308 * A) .....t..f..c..... Dtf < Dtc need to wait 309 * A) .....f..c..t..... Dtf < Dtc need to wait 310 * A) .....f..t..c..... Dtf > Dtc expired 311 * 312 * So: 313 * Dtf >= Dtc implies EXPIRED (return true) 314 * Dtf < Dtc implies WAIT (return false) 315 * 316 * Note: If t is expired then we *cannot* wait on it. We would wait 317 * forever (hang the system). 318 * 319 * Note: do NOT get clever and remove the -thresh from both sides. It 320 * is NOT the same. 321 * 322 * If future valueis zero, we have a client managed sync point. In that 323 * case we do a direct comparison. 324 */ 325 if (!host1x_syncpt_client_managed(sp)) 326 return future_val - thresh >= current_val - thresh; 327 else 328 return (s32)(current_val - thresh) >= 0; 329 } 330 331 /* remove a wait pointed to by patch_addr */ 332 int host1x_syncpt_patch_wait(struct host1x_syncpt *sp, void *patch_addr) 333 { 334 return host1x_hw_syncpt_patch_wait(sp->host, sp, patch_addr); 335 } 336 337 int host1x_syncpt_init(struct host1x *host) 338 { 339 struct host1x_syncpt_base *bases; 340 struct host1x_syncpt *syncpt; 341 int i; 342 343 syncpt = devm_kzalloc(host->dev, sizeof(*syncpt) * host->info->nb_pts, 344 GFP_KERNEL); 345 if (!syncpt) 346 return -ENOMEM; 347 348 bases = devm_kzalloc(host->dev, sizeof(*bases) * host->info->nb_bases, 349 GFP_KERNEL); 350 if (!bases) 351 return -ENOMEM; 352 353 for (i = 0; i < host->info->nb_pts; i++) { 354 syncpt[i].id = i; 355 syncpt[i].host = host; 356 } 357 358 for (i = 0; i < host->info->nb_bases; i++) 359 bases[i].id = i; 360 361 host->syncpt = syncpt; 362 host->bases = bases; 363 364 host1x_syncpt_restore(host); 365 366 /* Allocate sync point to use for clearing waits for expired fences */ 367 host->nop_sp = host1x_syncpt_alloc(host, NULL, 0); 368 if (!host->nop_sp) 369 return -ENOMEM; 370 371 return 0; 372 } 373 374 struct host1x_syncpt *host1x_syncpt_request(struct device *dev, 375 unsigned long flags) 376 { 377 struct host1x *host = dev_get_drvdata(dev->parent); 378 return host1x_syncpt_alloc(host, dev, flags); 379 } 380 381 void host1x_syncpt_free(struct host1x_syncpt *sp) 382 { 383 if (!sp) 384 return; 385 386 host1x_syncpt_base_free(sp->base); 387 kfree(sp->name); 388 sp->base = NULL; 389 sp->dev = NULL; 390 sp->name = NULL; 391 sp->client_managed = false; 392 } 393 394 void host1x_syncpt_deinit(struct host1x *host) 395 { 396 int i; 397 struct host1x_syncpt *sp = host->syncpt; 398 for (i = 0; i < host->info->nb_pts; i++, sp++) 399 kfree(sp->name); 400 } 401 402 /* 403 * Read max. It indicates how many operations there are in queue, either in 404 * channel or in a software thread. 405 * */ 406 u32 host1x_syncpt_read_max(struct host1x_syncpt *sp) 407 { 408 smp_rmb(); 409 return (u32)atomic_read(&sp->max_val); 410 } 411 412 /* 413 * Read min, which is a shadow of the current sync point value in hardware. 414 */ 415 u32 host1x_syncpt_read_min(struct host1x_syncpt *sp) 416 { 417 smp_rmb(); 418 return (u32)atomic_read(&sp->min_val); 419 } 420 421 int host1x_syncpt_nb_pts(struct host1x *host) 422 { 423 return host->info->nb_pts; 424 } 425 426 int host1x_syncpt_nb_bases(struct host1x *host) 427 { 428 return host->info->nb_bases; 429 } 430 431 int host1x_syncpt_nb_mlocks(struct host1x *host) 432 { 433 return host->info->nb_mlocks; 434 } 435 436 struct host1x_syncpt *host1x_syncpt_get(struct host1x *host, u32 id) 437 { 438 if (host->info->nb_pts < id) 439 return NULL; 440 return host->syncpt + id; 441 } 442 443 struct host1x_syncpt_base *host1x_syncpt_get_base(struct host1x_syncpt *sp) 444 { 445 return sp ? sp->base : NULL; 446 } 447 448 u32 host1x_syncpt_base_id(struct host1x_syncpt_base *base) 449 { 450 return base->id; 451 } 452