drivers/mxc/gpu-viv/hal/kernel/gc_hal_kernel_interrupt_vg.c

   1 /****************************************************************************
   2 *
   3 *    Copyright (C) 2005 - 2011 by Vivante Corp.
   4 *
   5 *    This program is free software; you can redistribute it and/or modify
   6 *    it under the terms of the GNU General Public License as published by
   7 *    the Free Software Foundation; either version 2 of the license, or
   8 *    (at your option) any later version.
   9 *
  10 *    This program is distributed in the hope that it will be useful,
  11 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13 *    GNU General Public License for more details.
  14 *
  15 *    You should have received a copy of the GNU General Public License
  16 *    along with this program; if not write to the Free Software
  17 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 *
  19 *****************************************************************************/
  20
  21
  22
  23
  24 #include "gc_hal_kernel_precomp.h"
  25
  26 #if gcdENABLE_VG
  27
  28 /******************************************************************************\
  29 *********************** Support Functions and Definitions **********************
  30 \******************************************************************************/
  31
  32 /* Interruot statistics will be accumulated if not zero. */
  33 #define gcmENABLE_INTERRUPT_STATISTICS 0
  34
  35 #define _GC_OBJ_ZONE    gcvZONE_INTERRUPT
  36
  37 /* Object structure. */
  38 struct _gckVGINTERRUPT
  39 {
  40     /* Object. */
  41     gcsOBJECT                   object;
  42
  43     /* gckVGKERNEL pointer. */
  44     gckVGKERNEL                 kernel;
  45
  46     /* gckOS pointer. */
  47     gckOS                       os;
  48
  49     /* Interrupt handlers. */
  50     gctINTERRUPT_HANDLER        handlers[32];
  51
  52     /* Main interrupt handler thread. */
  53     gctTHREAD                   handler;
  54     gctBOOL                     terminate;
  55
  56     /* Interrupt FIFO. */
  57     gctSEMAPHORE                fifoValid;
  58     gctUINT32                   fifo[256];
  59     gctUINT                     fifoItems;
  60     gctUINT8                    head;
  61     gctUINT8                    tail;
  62
  63     /* Interrupt statistics. */
  64 #if gcmENABLE_INTERRUPT_STATISTICS
  65     gctUINT                     maxFifoItems;
  66     gctUINT                     fifoOverflow;
  67     gctUINT                     maxSimultaneous;
  68     gctUINT                     multipleCount;
  69 #endif
  70 };
  71
  72
  73 /*******************************************************************************
  74 **
  75 **  _ProcessInterrupt
  76 **
  77 **  The interrupt processor.
  78 **
  79 **  INPUT:
  80 **
  81 **      ThreadParameter
  82 **          Pointer to the gckVGINTERRUPT object.
  83 **
  84 **  OUTPUT:
  85 **
  86 **      Nothing.
  87 */
  88
  89 #if gcmENABLE_INTERRUPT_STATISTICS
  90 static void
  91 _ProcessInterrupt(
  92     gckVGINTERRUPT Interrupt,
  93     gctUINT_PTR TriggeredCount
  94     )
  95 #else
  96 static void
  97 _ProcessInterrupt(
  98     gckVGINTERRUPT Interrupt
  99     )
 100 #endif
 101 {
 102     gceSTATUS status;
 103     gctUINT32 triggered;
 104     gctUINT i;
 105
 106     /* Advance to the next entry. */
 107     Interrupt->tail      += 1;
 108     Interrupt->fifoItems -= 1;
 109
 110     /* Get the interrupt value. */
 111     triggered = Interrupt->fifo[Interrupt->tail];
 112     gcmkASSERT(triggered != 0);
 113
 114     gcmkTRACE_ZONE(
 115         gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 116         "%s: triggered=0x%08X\n",
 117         __FUNCTION__,
 118         triggered
 119         );
 120
 121     /* Walk through all possible interrupts. */
 122     for (i = 0; i < gcmSIZEOF(Interrupt->handlers); i += 1)
 123     {
 124         /* Test if interrupt happened. */
 125         if ((triggered & 1) == 1)
 126         {
 127 #if gcmENABLE_INTERRUPT_STATISTICS
 128             if (TriggeredCount != gcvNULL)
 129             {
 130                 (* TriggeredCount) += 1;
 131             }
 132 #endif
 133
 134             /* Make sure we have valid handler. */
 135             if (Interrupt->handlers[i] == gcvNULL)
 136             {
 137                 gcmkTRACE(
 138                     gcvLEVEL_ERROR,
 139                     "%s: Interrupt %d isn't registered.\n",
 140                     __FUNCTION__, i
 141                     );
 142             }
 143             else
 144             {
 145                 gcmkTRACE_ZONE(
 146                     gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 147                     "%s: interrupt=%d\n",
 148                     __FUNCTION__,
 149                     i
 150                     );
 151
 152                 /* Call the handler. */
 153                 status = Interrupt->handlers[i] (Interrupt->kernel);
 154
 155                 if (gcmkIS_ERROR(status))
 156                 {
 157                     /* Failed to signal the semaphore. */
 158                     gcmkTRACE(
 159                         gcvLEVEL_ERROR,
 160                         "%s: Error %d incrementing the semaphore #%d.\n",
 161                         __FUNCTION__, status, i
 162                         );
 163                 }
 164             }
 165         }
 166
 167         /* Next interrupt. */
 168         triggered >>= 1;
 169
 170         /* No more interrupts to handle? */
 171         if (triggered == 0)
 172         {
 173             break;
 174         }
 175     }
 176 }
 177
 178
 179 /*******************************************************************************
 180 **
 181 **  _MainInterruptHandler
 182 **
 183 **  The main interrupt thread serves the interrupt FIFO and calls registered
 184 **  handlers for the interrupts that occured. The handlers are called in the
 185 **  sequence interrupts occured with the exception when multiple interrupts
 186 **  occured at the same time. In that case the handler calls are "sorted" by
 187 **  the interrupt number therefore giving the interrupts with lower numbers
 188 **  higher priority.
 189 **
 190 **  INPUT:
 191 **
 192 **      ThreadParameter
 193 **          Pointer to the gckVGINTERRUPT object.
 194 **
 195 **  OUTPUT:
 196 **
 197 **      Nothing.
 198 */
 199
 200 static gctTHREADFUNCRESULT gctTHREADFUNCTYPE
 201 _MainInterruptHandler(
 202     gctTHREADFUNCPARAMETER ThreadParameter
 203     )
 204 {
 205     gceSTATUS status;
 206     gckVGINTERRUPT interrupt;
 207
 208 #if gcmENABLE_INTERRUPT_STATISTICS
 209     gctUINT count;
 210 #endif
 211
 212     /* Cast the object. */
 213     interrupt = (gckVGINTERRUPT) ThreadParameter;
 214
 215     /* Enter the loop. */
 216     while (gcvTRUE)
 217     {
 218         /* Wait for an interrupt. */
 219         status = gckOS_DecrementSemaphore(interrupt->os, interrupt->fifoValid);
 220
 221         /* Error? */
 222         if (gcmkIS_ERROR(status))
 223         {
 224             break;
 225         }
 226
 227         /* System termination request? */
 228         if (status == gcvSTATUS_TERMINATE)
 229         {
 230             break;
 231         }
 232
 233         /* Driver is shutting down? */
 234         if (interrupt->terminate)
 235         {
 236             break;
 237         }
 238
 239 #if gcmENABLE_INTERRUPT_STATISTICS
 240         /* Reset triggered count. */
 241         count = 0;
 242
 243         /* Process the interrupt. */
 244         _ProcessInterrupt(interrupt, &count);
 245
 246         /* Update conters. */
 247         if (count > interrupt->maxSimultaneous)
 248         {
 249             interrupt->maxSimultaneous = count;
 250         }
 251
 252         if (count > 1)
 253         {
 254             interrupt->multipleCount += 1;
 255         }
 256 #else
 257         /* Process the interrupt. */
 258         _ProcessInterrupt(interrupt);
 259 #endif
 260     }
 261
 262     return 0;
 263 }
 264
 265
 266 /*******************************************************************************
 267 **
 268 **  _StartInterruptHandler / _StopInterruptHandler
 269 **
 270 **  Main interrupt handler routine control.
 271 **
 272 **  INPUT:
 273 **
 274 **      ThreadParameter
 275 **          Pointer to the gckVGINTERRUPT object.
 276 **
 277 **  OUTPUT:
 278 **
 279 **      Nothing.
 280 */
 281
 282 static gceSTATUS
 283 _StartInterruptHandler(
 284     gckVGINTERRUPT Interrupt
 285     )
 286 {
 287     gceSTATUS status, last;
 288
 289     do
 290     {
 291         /* Objects must not be already created. */
 292         gcmkASSERT(Interrupt->fifoValid == gcvNULL);
 293         gcmkASSERT(Interrupt->handler   == gcvNULL);
 294
 295         /* Reset the termination request. */
 296         Interrupt->terminate = gcvFALSE;
 297
 298 #if !gcdENABLE_INFINITE_SPEED_HW
 299         /* Construct the fifo semaphore. */
 300         gcmkERR_BREAK(gckOS_CreateSemaphoreVG(
 301             Interrupt->os, &Interrupt->fifoValid
 302             ));
 303
 304         /* Start the interrupt handler thread. */
 305         gcmkERR_BREAK(gckOS_StartThread(
 306             Interrupt->os,
 307             _MainInterruptHandler,
 308             Interrupt,
 309             &Interrupt->handler
 310             ));
 311 #endif
 312
 313         /* Success. */
 314         return gcvSTATUS_OK;
 315     }
 316     while (gcvFALSE);
 317
 318     /* Roll back. */
 319     if (Interrupt->fifoValid != gcvNULL)
 320     {
 321         gcmkCHECK_STATUS(gckOS_DestroySemaphore(
 322             Interrupt->os, Interrupt->fifoValid
 323             ));
 324
 325         Interrupt->fifoValid = gcvNULL;
 326     }
 327
 328     /* Return the status. */
 329     return status;
 330 }
 331
 332 static gceSTATUS
 333 _StopInterruptHandler(
 334     gckVGINTERRUPT Interrupt
 335     )
 336 {
 337     gceSTATUS status;
 338
 339     do
 340     {
 341         /* Does the thread exist? */
 342         if (Interrupt->handler == gcvNULL)
 343         {
 344             /* The semaphore must be NULL as well. */
 345             gcmkASSERT(Interrupt->fifoValid == gcvNULL);
 346
 347             /* Success. */
 348             status = gcvSTATUS_OK;
 349             break;
 350         }
 351
 352         /* The semaphore must exist as well. */
 353         gcmkASSERT(Interrupt->fifoValid != gcvNULL);
 354
 355         /* Set the termination request. */
 356         Interrupt->terminate = gcvTRUE;
 357
 358         /* Unlock the thread. */
 359         gcmkERR_BREAK(gckOS_IncrementSemaphore(
 360             Interrupt->os, Interrupt->fifoValid
 361             ));
 362
 363         /* Wait until the thread quits. */
 364         gcmkERR_BREAK(gckOS_StopThread(
 365             Interrupt->os,
 366             Interrupt->handler
 367             ));
 368
 369         /* Destroy the semaphore. */
 370         gcmkERR_BREAK(gckOS_DestroySemaphore(
 371             Interrupt->os, Interrupt->fifoValid
 372             ));
 373
 374         /* Reset handles. */
 375         Interrupt->handler   = gcvNULL;
 376         Interrupt->fifoValid = gcvNULL;
 377     }
 378     while (gcvFALSE);
 379
 380     /* Return the status. */
 381     return status;
 382 }
 383
 384
 385 /******************************************************************************\
 386 ***************************** Interrupt Object API *****************************
 387 \******************************************************************************/
 388
 389 /*******************************************************************************
 390 **
 391 **  gckVGINTERRUPT_Construct
 392 **
 393 **  Construct an interrupt object.
 394 **
 395 **  INPUT:
 396 **
 397 **      Kernel
 398 **          Pointer to the gckVGKERNEL object.
 399 **
 400 **  OUTPUT:
 401 **
 402 **      Interrupt
 403 **          Pointer to the new gckVGINTERRUPT object.
 404 */
 405
 406 gceSTATUS
 407 gckVGINTERRUPT_Construct(
 408     IN gckVGKERNEL Kernel,
 409     OUT gckVGINTERRUPT * Interrupt
 410     )
 411 {
 412     gceSTATUS status;
 413     gckVGINTERRUPT interrupt = gcvNULL;
 414
 415     gcmkHEADER_ARG("Kernel=0x%x Interrupt=0x%x", Kernel, Interrupt);
 416
 417     /* Verify argeuments. */
 418     gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
 419     gcmkVERIFY_ARGUMENT(Interrupt != gcvNULL);
 420
 421     do
 422     {
 423         /* Allocate the gckVGINTERRUPT structure. */
 424         gcmkERR_BREAK(gckOS_Allocate(
 425             Kernel->os,
 426             gcmSIZEOF(struct _gckVGINTERRUPT),
 427             (gctPOINTER *) &interrupt
 428             ));
 429
 430         /* Reset the object data. */
 431         gcmkVERIFY_OK(gckOS_ZeroMemory(
 432             interrupt, gcmSIZEOF(struct _gckVGINTERRUPT)
 433             ));
 434
 435         /* Initialize the object. */
 436         interrupt->object.type = gcvOBJ_INTERRUPT;
 437
 438         /* Initialize the object pointers. */
 439         interrupt->kernel = Kernel;
 440         interrupt->os     = Kernel->os;
 441
 442         /* Initialize the current FIFO position. */
 443         interrupt->head = (gctUINT8)~0;
 444         interrupt->tail = (gctUINT8)~0;
 445
 446         /* Start the thread. */
 447         gcmkERR_BREAK(_StartInterruptHandler(interrupt));
 448
 449         /* Return interrupt object. */
 450         *Interrupt = interrupt;
 451
 452         /* Success. */
 453         return gcvSTATUS_OK;
 454     }
 455     while (gcvFALSE);
 456
 457     /* Roll back. */
 458     if (interrupt != gcvNULL)
 459     {
 460         /* Free the gckVGINTERRUPT structure. */
 461         gcmkVERIFY_OK(gckOS_Free(interrupt->os, interrupt));
 462     }
 463
 464     /* Return the status. */
 465     return status;
 466 }
 467
 468
 469 /*******************************************************************************
 470 **
 471 **  gckVGINTERRUPT_Destroy
 472 **
 473 **  Destroy an interrupt object.
 474 **
 475 **  INPUT:
 476 **
 477 **      Interrupt
 478 **          Pointer to the gckVGINTERRUPT object to destroy.
 479 **
 480 **  OUTPUT:
 481 **
 482 **      Nothing.
 483 */
 484
 485 gceSTATUS
 486 gckVGINTERRUPT_Destroy(
 487     IN gckVGINTERRUPT Interrupt
 488     )
 489 {
 490     gceSTATUS status;
 491
 492     gcmkHEADER_ARG("Interrupt=0x%x", Interrupt);
 493
 494     /* Verify the arguments. */
 495     gcmkVERIFY_OBJECT(Interrupt, gcvOBJ_INTERRUPT);
 496
 497     do
 498     {
 499         /* Stop the interrupt thread. */
 500         gcmkERR_BREAK(_StopInterruptHandler(Interrupt));
 501
 502         /* Mark the object as unknown. */
 503         Interrupt->object.type = gcvOBJ_UNKNOWN;
 504
 505         /* Free the gckVGINTERRUPT structure. */
 506         gcmkERR_BREAK(gckOS_Free(Interrupt->os, Interrupt));
 507     }
 508     while (gcvFALSE);
 509
 510     gcmkFOOTER();
 511
 512     /* Return the status. */
 513     return status;
 514 }
 515
 516
 517 /*******************************************************************************
 518 **
 519 **  gckVGINTERRUPT_DumpState
 520 **
 521 **  Print the current state of the interrupt manager.
 522 **
 523 **  INPUT:
 524 **
 525 **      Interrupt
 526 **          Pointer to a gckVGINTERRUPT object.
 527 **
 528 **  OUTPUT:
 529 **
 530 **      Nothing.
 531 */
 532
 533 #if gcvDEBUG
 534 gceSTATUS
 535 gckVGINTERRUPT_DumpState(
 536     IN gckVGINTERRUPT Interrupt
 537     )
 538 {
 539     gcmkHEADER_ARG("Interrupt=0x%x", Interrupt);
 540     /* Verify the arguments. */
 541     gcmkVERIFY_OBJECT(Interrupt, gcvOBJ_INTERRUPT);
 542
 543     /* Print the header. */
 544     gcmkTRACE_ZONE(
 545         gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 546         "%s: INTERRUPT OBJECT STATUS\n",
 547         __FUNCTION__
 548         );
 549
 550     /* Print statistics. */
 551 #if gcmENABLE_INTERRUPT_STATISTICS
 552     gcmkTRACE_ZONE(
 553         gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 554         "  Maximum number of FIFO items accumulated at a single time: %d\n",
 555         Interrupt->maxFifoItems
 556         );
 557
 558     gcmkTRACE_ZONE(
 559         gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 560         "  Interrupt FIFO overflow happened times: %d\n",
 561         Interrupt->fifoOverflow
 562         );
 563
 564     gcmkTRACE_ZONE(
 565         gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 566         "  Maximum number of interrupts simultaneously generated: %d\n",
 567         Interrupt->maxSimultaneous
 568         );
 569
 570     gcmkTRACE_ZONE(
 571         gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 572         "  Number of times when there were multiple interrupts generated: %d\n",
 573         Interrupt->multipleCount
 574         );
 575 #endif
 576
 577     gcmkTRACE_ZONE(
 578         gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 579         "  The current number of entries in the FIFO: %d\n",
 580         Interrupt->fifoItems
 581         );
 582
 583     /* Print the FIFO contents. */
 584     if (Interrupt->fifoItems != 0)
 585     {
 586         gctUINT8 index;
 587         gctUINT8 last;
 588
 589         gcmkTRACE_ZONE(
 590             gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 591             "  FIFO current contents:\n"
 592             );
 593
 594         /* Get the current pointers. */
 595         index = Interrupt->tail;
 596         last  = Interrupt->head;
 597
 598         while (index != last)
 599         {
 600             /* Advance to the next entry. */
 601             index += 1;
 602
 603             gcmkTRACE_ZONE(
 604                 gcvLEVEL_VERBOSE, gcvZONE_COMMAND,
 605                 "    %d: 0x%08X\n",
 606                 index, Interrupt->fifo[index]
 607                 );
 608         }
 609     }
 610
 611     gcmkFOOTER_NO();
 612     /* Success. */
 613     return gcvSTATUS_OK;
 614 }
 615 #endif
 616
 617
 618 /*******************************************************************************
 619 **
 620 **  gckVGINTERRUPT_Enable
 621 **
 622 **  Enable the specified interrupt.
 623 **
 624 **  INPUT:
 625 **
 626 **      Interrupt
 627 **          Pointer to a gckVGINTERRUPT object.
 628 **
 629 **      Id
 630 **          Pointer to the variable that holds the interrupt number to be
 631 **          registered in range 0..31.
 632 **          If the value is less then 0, gckVGINTERRUPT_Enable will attempt
 633 **          to find an unused interrupt. If such interrupt is found, the number
 634 **          will be assigned to the variable if the functuion call succeedes.
 635 **
 636 **      Handler
 637 **          Pointer to the handler to register for the interrupt.
 638 **
 639 **  OUTPUT:
 640 **
 641 **      Nothing.
 642 */
 643
 644 gceSTATUS
 645 gckVGINTERRUPT_Enable(
 646     IN gckVGINTERRUPT Interrupt,
 647     IN OUT gctINT32_PTR Id,
 648     IN gctINTERRUPT_HANDLER Handler
 649     )
 650 {
 651     gceSTATUS status;
 652     gctINT32 i;
 653
 654     gcmkHEADER_ARG("Interrupt=0x%x Id=0x%x Handler=0x%x", Interrupt, Id, Handler);
 655
 656     /* Verify the arguments. */
 657     gcmkVERIFY_OBJECT(Interrupt, gcvOBJ_INTERRUPT);
 658     gcmkVERIFY_ARGUMENT(Id != gcvNULL);
 659     gcmkVERIFY_ARGUMENT(Handler != gcvNULL);
 660
 661     do
 662     {
 663         /* See if we need to allocate an ID. */
 664         if (*Id < 0)
 665         {
 666             /* Find the first unused interrupt handler. */
 667             for (i = 0; i < gcmCOUNTOF(Interrupt->handlers); ++i)
 668             {
 669                 if (Interrupt->handlers[i] == gcvNULL)
 670                 {
 671                     break;
 672                 }
 673             }
 674
 675             /* No unused innterrupts? */
 676             if (i == gcmCOUNTOF(Interrupt->handlers))
 677             {
 678                 status = gcvSTATUS_OUT_OF_RESOURCES;
 679                 break;
 680             }
 681
 682             /* Update the interrupt ID. */
 683             *Id = i;
 684         }
 685
 686         /* Make sure the ID is in range. */
 687         else if (*Id >= gcmCOUNTOF(Interrupt->handlers))
 688         {
 689             status = gcvSTATUS_INVALID_ARGUMENT;
 690             break;
 691         }
 692
 693         /* Set interrupt handler. */
 694         Interrupt->handlers[*Id] = Handler;
 695
 696         /* Success. */
 697         status = gcvSTATUS_OK;
 698     }
 699     while (gcvFALSE);
 700
 701     gcmkFOOTER();
 702     /* Return the status. */
 703     return status;
 704 }
 705
 706
 707 /*******************************************************************************
 708 **
 709 **  gckVGINTERRUPT_Disable
 710 **
 711 **  Disable the specified interrupt.
 712 **
 713 **  INPUT:
 714 **
 715 **      Interrupt
 716 **          Pointer to a gckVGINTERRUPT object.
 717 **
 718 **      Id
 719 **          Interrupt number to be disabled in range 0..31.
 720 **
 721 **  OUTPUT:
 722 **
 723 **      Nothing.
 724 */
 725
 726 gceSTATUS
 727 gckVGINTERRUPT_Disable(
 728     IN gckVGINTERRUPT Interrupt,
 729     IN gctINT32 Id
 730     )
 731 {
 732     gcmkHEADER_ARG("Interrupt=0x%x Id=0x%x", Interrupt, Id);
 733     /* Verify the arguments. */
 734     gcmkVERIFY_OBJECT(Interrupt, gcvOBJ_INTERRUPT);
 735     gcmkVERIFY_ARGUMENT((Id >= 0) && (Id < gcmCOUNTOF(Interrupt->handlers)));
 736
 737     /* Reset interrupt handler. */
 738     Interrupt->handlers[Id] = gcvNULL;
 739
 740     gcmkFOOTER_NO();
 741     /* Success. */
 742     return gcvSTATUS_OK;
 743 }
 744
 745
 746 /*******************************************************************************
 747 **
 748 **  gckVGINTERRUPT_Enque
 749 **
 750 **  Read the interrupt status register and put the value in the interrupt FIFO.
 751 **
 752 **  INPUT:
 753 **
 754 **      Interrupt
 755 **          Pointer to a gckVGINTERRUPT object.
 756 **
 757 **  OUTPUT:
 758 **
 759 **      Nothing.
 760 */
 761
 762 gceSTATUS
 763 gckVGINTERRUPT_Enque(
 764     IN gckVGINTERRUPT Interrupt
 765     )
 766 {
 767     gceSTATUS status;
 768     gctUINT32 triggered;
 769
 770     gcmkHEADER_ARG("Interrupt=0x%x", Interrupt);
 771
 772     /* Verify the arguments. */
 773     gcmkVERIFY_OBJECT(Interrupt, gcvOBJ_INTERRUPT);
 774
 775     do
 776     {
 777         /* Read interrupt status register. */
 778         gcmkERR_BREAK(gckVGHARDWARE_ReadInterrupt(
 779             Interrupt->kernel->hardware, &triggered
 780             ));
 781
 782         /* No interrupts to process? */
 783         if (triggered == 0)
 784         {
 785             status = gcvSTATUS_NOT_OUR_INTERRUPT;
 786             break;
 787         }
 788
 789         /* FIFO overflow? */
 790         if (Interrupt->fifoItems == gcmCOUNTOF(Interrupt->fifo))
 791         {
 792 #if gcmENABLE_INTERRUPT_STATISTICS
 793             Interrupt->fifoOverflow += 1;
 794 #endif
 795
 796             /* OR the interrupt with the last value in the FIFO. */
 797             Interrupt->fifo[Interrupt->head] |= triggered;
 798
 799             /* Success (kind of). */
 800             status = gcvSTATUS_OK;
 801         }
 802         else
 803         {
 804             /* Advance to the next entry. */
 805             Interrupt->head      += 1;
 806             Interrupt->fifoItems += 1;
 807
 808 #if gcmENABLE_INTERRUPT_STATISTICS
 809             if (Interrupt->fifoItems > Interrupt->maxFifoItems)
 810             {
 811                 Interrupt->maxFifoItems = Interrupt->fifoItems;
 812             }
 813 #endif
 814
 815             /* Set the new value. */
 816             Interrupt->fifo[Interrupt->head] = triggered;
 817
 818             /* Increment the FIFO semaphore. */
 819             gcmkERR_BREAK(gckOS_IncrementSemaphore(
 820                 Interrupt->os, Interrupt->fifoValid
 821                 ));
 822
 823             /* Windows kills our threads prematurely when the application
 824                exists. Verify here that the thread is still alive. */
 825             status = gckOS_VerifyThread(Interrupt->os, Interrupt->handler);
 826
 827             /* Has the thread been prematurely terminated? */
 828             if (status != gcvSTATUS_OK)
 829             {
 830                 /* Process all accumulated interrupts. */
 831                 while (Interrupt->head != Interrupt->tail)
 832                 {
 833 #if gcmENABLE_INTERRUPT_STATISTICS
 834                     /* Process the interrupt. */
 835                     _ProcessInterrupt(Interrupt, gcvNULL);
 836 #else
 837                     /* Process the interrupt. */
 838                     _ProcessInterrupt(Interrupt);
 839 #endif
 840                 }
 841
 842                 /* Set success. */
 843                 status = gcvSTATUS_OK;
 844             }
 845         }
 846     }
 847     while (gcvFALSE);
 848
 849     gcmkFOOTER();
 850     /* Return status. */
 851     return status;
 852 }
 853
 854 #endif /* gcdENABLE_VG */