drivers/gpu/host1x/syncpt.c

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