root/drivers/gpu/drm/i915/selftests/i915_sw_fence.c

DEFINITIONS

1. fence_notify
2. alloc_fence
3. free_fence
4. __test_self
5. test_self
6. test_dag
7. test_AB
8. test_ABC
9. test_AB_C
10. test_C_AB
11. test_chain
12. task_ipc
13. test_ipc
14. test_timer
15. mock_name
16. alloc_dma_fence
17. wrap_dma_fence
18. test_dma_fence
19. i915_sw_fence_mock_selftests

   1 /*
   2  * Copyright © 2017 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  */
  24 
  25 #include <linux/completion.h>
  26 #include <linux/delay.h>
  27 #include <linux/prime_numbers.h>
  28 
  29 #include "../i915_selftest.h"
  30 
  31 static int __i915_sw_fence_call
  32 fence_notify(struct i915_sw_fence *fence, enum i915_sw_fence_notify state)
  33 {
  34         switch (state) {
  35         case FENCE_COMPLETE:
  36                 break;
  37 
  38         case FENCE_FREE:
  39                 /* Leave the fence for the caller to free it after testing */
  40                 break;
  41         }
  42 
  43         return NOTIFY_DONE;
  44 }
  45 
  46 static struct i915_sw_fence *alloc_fence(void)
  47 {
  48         struct i915_sw_fence *fence;
  49 
  50         fence = kmalloc(sizeof(*fence), GFP_KERNEL);
  51         if (!fence)
  52                 return NULL;
  53 
  54         i915_sw_fence_init(fence, fence_notify);
  55         return fence;
  56 }
  57 
  58 static void free_fence(struct i915_sw_fence *fence)
  59 {
  60         i915_sw_fence_fini(fence);
  61         kfree(fence);
  62 }
  63 
  64 static int __test_self(struct i915_sw_fence *fence)
  65 {
  66         if (i915_sw_fence_done(fence))
  67                 return -EINVAL;
  68 
  69         i915_sw_fence_commit(fence);
  70         if (!i915_sw_fence_done(fence))
  71                 return -EINVAL;
  72 
  73         i915_sw_fence_wait(fence);
  74         if (!i915_sw_fence_done(fence))
  75                 return -EINVAL;
  76 
  77         return 0;
  78 }
  79 
  80 static int test_self(void *arg)
  81 {
  82         struct i915_sw_fence *fence;
  83         int ret;
  84 
  85         /* Test i915_sw_fence signaling and completion testing */
  86         fence = alloc_fence();
  87         if (!fence)
  88                 return -ENOMEM;
  89 
  90         ret = __test_self(fence);
  91 
  92         free_fence(fence);
  93         return ret;
  94 }
  95 
  96 static int test_dag(void *arg)
  97 {
  98         struct i915_sw_fence *A, *B, *C;
  99         int ret = -EINVAL;
 100 
 101         /* Test detection of cycles within the i915_sw_fence graphs */
 102         if (!IS_ENABLED(CONFIG_DRM_I915_SW_FENCE_CHECK_DAG))
 103                 return 0;
 104 
 105         A = alloc_fence();
 106         if (!A)
 107                 return -ENOMEM;
 108 
 109         if (i915_sw_fence_await_sw_fence_gfp(A, A, GFP_KERNEL) != -EINVAL) {
 110                 pr_err("recursive cycle not detected (AA)\n");
 111                 goto err_A;
 112         }
 113 
 114         B = alloc_fence();
 115         if (!B) {
 116                 ret = -ENOMEM;
 117                 goto err_A;
 118         }
 119 
 120         i915_sw_fence_await_sw_fence_gfp(A, B, GFP_KERNEL);
 121         if (i915_sw_fence_await_sw_fence_gfp(B, A, GFP_KERNEL) != -EINVAL) {
 122                 pr_err("single depth cycle not detected (BAB)\n");
 123                 goto err_B;
 124         }
 125 
 126         C = alloc_fence();
 127         if (!C) {
 128                 ret = -ENOMEM;
 129                 goto err_B;
 130         }
 131 
 132         if (i915_sw_fence_await_sw_fence_gfp(B, C, GFP_KERNEL) == -EINVAL) {
 133                 pr_err("invalid cycle detected\n");
 134                 goto err_C;
 135         }
 136         if (i915_sw_fence_await_sw_fence_gfp(C, B, GFP_KERNEL) != -EINVAL) {
 137                 pr_err("single depth cycle not detected (CBC)\n");
 138                 goto err_C;
 139         }
 140         if (i915_sw_fence_await_sw_fence_gfp(C, A, GFP_KERNEL) != -EINVAL) {
 141                 pr_err("cycle not detected (BA, CB, AC)\n");
 142                 goto err_C;
 143         }
 144         if (i915_sw_fence_await_sw_fence_gfp(A, C, GFP_KERNEL) == -EINVAL) {
 145                 pr_err("invalid cycle detected\n");
 146                 goto err_C;
 147         }
 148 
 149         i915_sw_fence_commit(A);
 150         i915_sw_fence_commit(B);
 151         i915_sw_fence_commit(C);
 152 
 153         ret = 0;
 154         if (!i915_sw_fence_done(C)) {
 155                 pr_err("fence C not done\n");
 156                 ret = -EINVAL;
 157         }
 158         if (!i915_sw_fence_done(B)) {
 159                 pr_err("fence B not done\n");
 160                 ret = -EINVAL;
 161         }
 162         if (!i915_sw_fence_done(A)) {
 163                 pr_err("fence A not done\n");
 164                 ret = -EINVAL;
 165         }
 166 err_C:
 167         free_fence(C);
 168 err_B:
 169         free_fence(B);
 170 err_A:
 171         free_fence(A);
 172         return ret;
 173 }
 174 
 175 static int test_AB(void *arg)
 176 {
 177         struct i915_sw_fence *A, *B;
 178         int ret;
 179 
 180         /* Test i915_sw_fence (A) waiting on an event source (B) */
 181         A = alloc_fence();
 182         if (!A)
 183                 return -ENOMEM;
 184         B = alloc_fence();
 185         if (!B) {
 186                 ret = -ENOMEM;
 187                 goto err_A;
 188         }
 189 
 190         ret = i915_sw_fence_await_sw_fence_gfp(A, B, GFP_KERNEL);
 191         if (ret < 0)
 192                 goto err_B;
 193         if (ret == 0) {
 194                 pr_err("Incorrectly reported fence A was complete before await\n");
 195                 ret = -EINVAL;
 196                 goto err_B;
 197         }
 198 
 199         ret = -EINVAL;
 200         i915_sw_fence_commit(A);
 201         if (i915_sw_fence_done(A))
 202                 goto err_B;
 203 
 204         i915_sw_fence_commit(B);
 205         if (!i915_sw_fence_done(B)) {
 206                 pr_err("Fence B is not done\n");
 207                 goto err_B;
 208         }
 209 
 210         if (!i915_sw_fence_done(A)) {
 211                 pr_err("Fence A is not done\n");
 212                 goto err_B;
 213         }
 214 
 215         ret = 0;
 216 err_B:
 217         free_fence(B);
 218 err_A:
 219         free_fence(A);
 220         return ret;
 221 }
 222 
 223 static int test_ABC(void *arg)
 224 {
 225         struct i915_sw_fence *A, *B, *C;
 226         int ret;
 227 
 228         /* Test a chain of fences, A waits on B who waits on C */
 229         A = alloc_fence();
 230         if (!A)
 231                 return -ENOMEM;
 232 
 233         B = alloc_fence();
 234         if (!B) {
 235                 ret = -ENOMEM;
 236                 goto err_A;
 237         }
 238 
 239         C = alloc_fence();
 240         if (!C) {
 241                 ret = -ENOMEM;
 242                 goto err_B;
 243         }
 244 
 245         ret = i915_sw_fence_await_sw_fence_gfp(A, B, GFP_KERNEL);
 246         if (ret < 0)
 247                 goto err_C;
 248         if (ret == 0) {
 249                 pr_err("Incorrectly reported fence B was complete before await\n");
 250                 goto err_C;
 251         }
 252 
 253         ret = i915_sw_fence_await_sw_fence_gfp(B, C, GFP_KERNEL);
 254         if (ret < 0)
 255                 goto err_C;
 256         if (ret == 0) {
 257                 pr_err("Incorrectly reported fence C was complete before await\n");
 258                 goto err_C;
 259         }
 260 
 261         ret = -EINVAL;
 262         i915_sw_fence_commit(A);
 263         if (i915_sw_fence_done(A)) {
 264                 pr_err("Fence A completed early\n");
 265                 goto err_C;
 266         }
 267 
 268         i915_sw_fence_commit(B);
 269         if (i915_sw_fence_done(B)) {
 270                 pr_err("Fence B completed early\n");
 271                 goto err_C;
 272         }
 273 
 274         if (i915_sw_fence_done(A)) {
 275                 pr_err("Fence A completed early (after signaling B)\n");
 276                 goto err_C;
 277         }
 278 
 279         i915_sw_fence_commit(C);
 280 
 281         ret = 0;
 282         if (!i915_sw_fence_done(C)) {
 283                 pr_err("Fence C not done\n");
 284                 ret = -EINVAL;
 285         }
 286         if (!i915_sw_fence_done(B)) {
 287                 pr_err("Fence B not done\n");
 288                 ret = -EINVAL;
 289         }
 290         if (!i915_sw_fence_done(A)) {
 291                 pr_err("Fence A not done\n");
 292                 ret = -EINVAL;
 293         }
 294 err_C:
 295         free_fence(C);
 296 err_B:
 297         free_fence(B);
 298 err_A:
 299         free_fence(A);
 300         return ret;
 301 }
 302 
 303 static int test_AB_C(void *arg)
 304 {
 305         struct i915_sw_fence *A, *B, *C;
 306         int ret = -EINVAL;
 307 
 308         /* Test multiple fences (AB) waiting on a single event (C) */
 309         A = alloc_fence();
 310         if (!A)
 311                 return -ENOMEM;
 312 
 313         B = alloc_fence();
 314         if (!B) {
 315                 ret = -ENOMEM;
 316                 goto err_A;
 317         }
 318 
 319         C = alloc_fence();
 320         if (!C) {
 321                 ret = -ENOMEM;
 322                 goto err_B;
 323         }
 324 
 325         ret = i915_sw_fence_await_sw_fence_gfp(A, C, GFP_KERNEL);
 326         if (ret < 0)
 327                 goto err_C;
 328         if (ret == 0) {
 329                 ret = -EINVAL;
 330                 goto err_C;
 331         }
 332 
 333         ret = i915_sw_fence_await_sw_fence_gfp(B, C, GFP_KERNEL);
 334         if (ret < 0)
 335                 goto err_C;
 336         if (ret == 0) {
 337                 ret = -EINVAL;
 338                 goto err_C;
 339         }
 340 
 341         i915_sw_fence_commit(A);
 342         i915_sw_fence_commit(B);
 343 
 344         ret = 0;
 345         if (i915_sw_fence_done(A)) {
 346                 pr_err("Fence A completed early\n");
 347                 ret = -EINVAL;
 348         }
 349 
 350         if (i915_sw_fence_done(B)) {
 351                 pr_err("Fence B completed early\n");
 352                 ret = -EINVAL;
 353         }
 354 
 355         i915_sw_fence_commit(C);
 356         if (!i915_sw_fence_done(C)) {
 357                 pr_err("Fence C not done\n");
 358                 ret = -EINVAL;
 359         }
 360 
 361         if (!i915_sw_fence_done(B)) {
 362                 pr_err("Fence B not done\n");
 363                 ret = -EINVAL;
 364         }
 365 
 366         if (!i915_sw_fence_done(A)) {
 367                 pr_err("Fence A not done\n");
 368                 ret = -EINVAL;
 369         }
 370 
 371 err_C:
 372         free_fence(C);
 373 err_B:
 374         free_fence(B);
 375 err_A:
 376         free_fence(A);
 377         return ret;
 378 }
 379 
 380 static int test_C_AB(void *arg)
 381 {
 382         struct i915_sw_fence *A, *B, *C;
 383         int ret;
 384 
 385         /* Test multiple event sources (A,B) for a single fence (C) */
 386         A = alloc_fence();
 387         if (!A)
 388                 return -ENOMEM;
 389 
 390         B = alloc_fence();
 391         if (!B) {
 392                 ret = -ENOMEM;
 393                 goto err_A;
 394         }
 395 
 396         C = alloc_fence();
 397         if (!C) {
 398                 ret = -ENOMEM;
 399                 goto err_B;
 400         }
 401 
 402         ret = i915_sw_fence_await_sw_fence_gfp(C, A, GFP_KERNEL);
 403         if (ret < 0)
 404                 goto err_C;
 405         if (ret == 0) {
 406                 ret = -EINVAL;
 407                 goto err_C;
 408         }
 409 
 410         ret = i915_sw_fence_await_sw_fence_gfp(C, B, GFP_KERNEL);
 411         if (ret < 0)
 412                 goto err_C;
 413         if (ret == 0) {
 414                 ret = -EINVAL;
 415                 goto err_C;
 416         }
 417 
 418         ret = 0;
 419         i915_sw_fence_commit(C);
 420         if (i915_sw_fence_done(C))
 421                 ret = -EINVAL;
 422 
 423         i915_sw_fence_commit(A);
 424         i915_sw_fence_commit(B);
 425 
 426         if (!i915_sw_fence_done(A)) {
 427                 pr_err("Fence A not done\n");
 428                 ret = -EINVAL;
 429         }
 430 
 431         if (!i915_sw_fence_done(B)) {
 432                 pr_err("Fence B not done\n");
 433                 ret = -EINVAL;
 434         }
 435 
 436         if (!i915_sw_fence_done(C)) {
 437                 pr_err("Fence C not done\n");
 438                 ret = -EINVAL;
 439         }
 440 
 441 err_C:
 442         free_fence(C);
 443 err_B:
 444         free_fence(B);
 445 err_A:
 446         free_fence(A);
 447         return ret;
 448 }
 449 
 450 static int test_chain(void *arg)
 451 {
 452         int nfences = 4096;
 453         struct i915_sw_fence **fences;
 454         int ret, i;
 455 
 456         /* Test a long chain of fences */
 457         fences = kmalloc_array(nfences, sizeof(*fences), GFP_KERNEL);
 458         if (!fences)
 459                 return -ENOMEM;
 460 
 461         for (i = 0; i < nfences; i++) {
 462                 fences[i] = alloc_fence();
 463                 if (!fences[i]) {
 464                         nfences = i;
 465                         ret = -ENOMEM;
 466                         goto err;
 467                 }
 468 
 469                 if (i > 0) {
 470                         ret = i915_sw_fence_await_sw_fence_gfp(fences[i],
 471                                                                fences[i - 1],
 472                                                                GFP_KERNEL);
 473                         if (ret < 0) {
 474                                 nfences = i + 1;
 475                                 goto err;
 476                         }
 477 
 478                         i915_sw_fence_commit(fences[i]);
 479                 }
 480         }
 481 
 482         ret = 0;
 483         for (i = nfences; --i; ) {
 484                 if (i915_sw_fence_done(fences[i])) {
 485                         if (ret == 0)
 486                                 pr_err("Fence[%d] completed early\n", i);
 487                         ret = -EINVAL;
 488                 }
 489         }
 490         i915_sw_fence_commit(fences[0]);
 491         for (i = 0; ret == 0 && i < nfences; i++) {
 492                 if (!i915_sw_fence_done(fences[i])) {
 493                         pr_err("Fence[%d] is not done\n", i);
 494                         ret = -EINVAL;
 495                 }
 496         }
 497 
 498 err:
 499         for (i = 0; i < nfences; i++)
 500                 free_fence(fences[i]);
 501         kfree(fences);
 502         return ret;
 503 }
 504 
 505 struct task_ipc {
 506         struct work_struct work;
 507         struct completion started;
 508         struct i915_sw_fence *in, *out;
 509         int value;
 510 };
 511 
 512 static void task_ipc(struct work_struct *work)
 513 {
 514         struct task_ipc *ipc = container_of(work, typeof(*ipc), work);
 515 
 516         complete(&ipc->started);
 517 
 518         i915_sw_fence_wait(ipc->in);
 519         smp_store_mb(ipc->value, 1);
 520         i915_sw_fence_commit(ipc->out);
 521 }
 522 
 523 static int test_ipc(void *arg)
 524 {
 525         struct task_ipc ipc;
 526         int ret = 0;
 527 
 528         /* Test use of i915_sw_fence as an interprocess signaling mechanism */
 529         ipc.in = alloc_fence();
 530         if (!ipc.in)
 531                 return -ENOMEM;
 532         ipc.out = alloc_fence();
 533         if (!ipc.out) {
 534                 ret = -ENOMEM;
 535                 goto err_in;
 536         }
 537 
 538         /* use a completion to avoid chicken-and-egg testing */
 539         init_completion(&ipc.started);
 540 
 541         ipc.value = 0;
 542         INIT_WORK_ONSTACK(&ipc.work, task_ipc);
 543         schedule_work(&ipc.work);
 544 
 545         wait_for_completion(&ipc.started);
 546 
 547         usleep_range(1000, 2000);
 548         if (READ_ONCE(ipc.value)) {
 549                 pr_err("worker updated value before i915_sw_fence was signaled\n");
 550                 ret = -EINVAL;
 551         }
 552 
 553         i915_sw_fence_commit(ipc.in);
 554         i915_sw_fence_wait(ipc.out);
 555 
 556         if (!READ_ONCE(ipc.value)) {
 557                 pr_err("worker signaled i915_sw_fence before value was posted\n");
 558                 ret = -EINVAL;
 559         }
 560 
 561         flush_work(&ipc.work);
 562         destroy_work_on_stack(&ipc.work);
 563         free_fence(ipc.out);
 564 err_in:
 565         free_fence(ipc.in);
 566         return ret;
 567 }
 568 
 569 static int test_timer(void *arg)
 570 {
 571         unsigned long target, delay;
 572         struct timed_fence tf;
 573 
 574         preempt_disable();
 575         timed_fence_init(&tf, target = jiffies);
 576         if (!i915_sw_fence_done(&tf.fence)) {
 577                 pr_err("Fence with immediate expiration not signaled\n");
 578                 goto err;
 579         }
 580         preempt_enable();
 581         timed_fence_fini(&tf);
 582 
 583         for_each_prime_number(delay, i915_selftest.timeout_jiffies/2) {
 584                 preempt_disable();
 585                 timed_fence_init(&tf, target = jiffies + delay);
 586                 if (i915_sw_fence_done(&tf.fence)) {
 587                         pr_err("Fence with future expiration (%lu jiffies) already signaled\n", delay);
 588                         goto err;
 589                 }
 590                 preempt_enable();
 591 
 592                 i915_sw_fence_wait(&tf.fence);
 593 
 594                 preempt_disable();
 595                 if (!i915_sw_fence_done(&tf.fence)) {
 596                         pr_err("Fence not signaled after wait\n");
 597                         goto err;
 598                 }
 599                 if (time_before(jiffies, target)) {
 600                         pr_err("Fence signaled too early, target=%lu, now=%lu\n",
 601                                target, jiffies);
 602                         goto err;
 603                 }
 604                 preempt_enable();
 605                 timed_fence_fini(&tf);
 606         }
 607 
 608         return 0;
 609 
 610 err:
 611         preempt_enable();
 612         timed_fence_fini(&tf);
 613         return -EINVAL;
 614 }
 615 
 616 static const char *mock_name(struct dma_fence *fence)
 617 {
 618         return "mock";
 619 }
 620 
 621 static const struct dma_fence_ops mock_fence_ops = {
 622         .get_driver_name = mock_name,
 623         .get_timeline_name = mock_name,
 624 };
 625 
 626 static DEFINE_SPINLOCK(mock_fence_lock);
 627 
 628 static struct dma_fence *alloc_dma_fence(void)
 629 {
 630         struct dma_fence *dma;
 631 
 632         dma = kmalloc(sizeof(*dma), GFP_KERNEL);
 633         if (dma)
 634                 dma_fence_init(dma, &mock_fence_ops, &mock_fence_lock, 0, 0);
 635 
 636         return dma;
 637 }
 638 
 639 static struct i915_sw_fence *
 640 wrap_dma_fence(struct dma_fence *dma, unsigned long delay)
 641 {
 642         struct i915_sw_fence *fence;
 643         int err;
 644 
 645         fence = alloc_fence();
 646         if (!fence)
 647                 return ERR_PTR(-ENOMEM);
 648 
 649         err = i915_sw_fence_await_dma_fence(fence, dma, delay, GFP_NOWAIT);
 650         i915_sw_fence_commit(fence);
 651         if (err < 0) {
 652                 free_fence(fence);
 653                 return ERR_PTR(err);
 654         }
 655 
 656         return fence;
 657 }
 658 
 659 static int test_dma_fence(void *arg)
 660 {
 661         struct i915_sw_fence *timeout = NULL, *not = NULL;
 662         unsigned long delay = i915_selftest.timeout_jiffies;
 663         unsigned long end, sleep;
 664         struct dma_fence *dma;
 665         int err;
 666 
 667         dma = alloc_dma_fence();
 668         if (!dma)
 669                 return -ENOMEM;
 670 
 671         timeout = wrap_dma_fence(dma, delay);
 672         if (IS_ERR(timeout)) {
 673                 err = PTR_ERR(timeout);
 674                 goto err;
 675         }
 676 
 677         not = wrap_dma_fence(dma, 0);
 678         if (IS_ERR(not)) {
 679                 err = PTR_ERR(not);
 680                 goto err;
 681         }
 682 
 683         err = -EINVAL;
 684         if (i915_sw_fence_done(timeout) || i915_sw_fence_done(not)) {
 685                 pr_err("Fences immediately signaled\n");
 686                 goto err;
 687         }
 688 
 689         /* We round the timeout for the fence up to the next second */
 690         end = round_jiffies_up(jiffies + delay);
 691 
 692         sleep = jiffies_to_usecs(delay) / 3;
 693         usleep_range(sleep, 2 * sleep);
 694         if (time_after(jiffies, end)) {
 695                 pr_debug("Slept too long, delay=%lu, (target=%lu, now=%lu) skipping\n",
 696                          delay, end, jiffies);
 697                 goto skip;
 698         }
 699 
 700         if (i915_sw_fence_done(timeout) || i915_sw_fence_done(not)) {
 701                 pr_err("Fences signaled too early\n");
 702                 goto err;
 703         }
 704 
 705         if (!wait_event_timeout(timeout->wait,
 706                                 i915_sw_fence_done(timeout),
 707                                 2 * (end - jiffies) + 1)) {
 708                 pr_err("Timeout fence unsignaled!\n");
 709                 goto err;
 710         }
 711 
 712         if (i915_sw_fence_done(not)) {
 713                 pr_err("No timeout fence signaled!\n");
 714                 goto err;
 715         }
 716 
 717 skip:
 718         dma_fence_signal(dma);
 719 
 720         if (!i915_sw_fence_done(timeout) || !i915_sw_fence_done(not)) {
 721                 pr_err("Fences unsignaled\n");
 722                 goto err;
 723         }
 724 
 725         free_fence(not);
 726         free_fence(timeout);
 727         dma_fence_put(dma);
 728 
 729         return 0;
 730 
 731 err:
 732         dma_fence_signal(dma);
 733         if (!IS_ERR_OR_NULL(timeout))
 734                 free_fence(timeout);
 735         if (!IS_ERR_OR_NULL(not))
 736                 free_fence(not);
 737         dma_fence_put(dma);
 738         return err;
 739 }
 740 
 741 int i915_sw_fence_mock_selftests(void)
 742 {
 743         static const struct i915_subtest tests[] = {
 744                 SUBTEST(test_self),
 745                 SUBTEST(test_dag),
 746                 SUBTEST(test_AB),
 747                 SUBTEST(test_ABC),
 748                 SUBTEST(test_AB_C),
 749                 SUBTEST(test_C_AB),
 750                 SUBTEST(test_chain),
 751                 SUBTEST(test_ipc),
 752                 SUBTEST(test_timer),
 753                 SUBTEST(test_dma_fence),
 754         };
 755 
 756         return i915_subtests(tests, NULL);
 757 }