VirtualBox

Changeset 41636 in vbox


Ignore:
Timestamp:
Jun 9, 2012 12:56:51 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
78435
Message:

wddm: fix win8 halt issues

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/HGSMI/HGSMIChSetup.h

    r32622 r41636  
    4949/* one or more guest commands is completed */
    5050# define HGSMIHOSTFLAGS_GCOMMAND_COMPLETED 0x4
     51# define HGSMIHOSTFLAGS_WATCHDOG           0x8
    5152#endif
     53#define HGSMIHOSTFLAGS_VSYNC               0x10
    5254
    5355typedef struct _HGSMIHOSTFLAGS

  • trunk/include/VBox/VBoxVideo.h

    r41058 r41636  
    850850# define VBVA_VDMA_CMD    11 /* G->H DMA command             */
    851851#endif
    852 #define VBVA_INFO_CAPS   12 /* informs host about HGSMI caps. see _VBVACAPS below */
     852#define VBVA_INFO_CAPS   12 /* informs host about HGSMI caps. see VBVACAPS below */
     853#define VBVA_SCANLINE_CFG    13 /* configures scanline, see VBVASCANLINECFG below */
     854#define VBVA_SCANLINE_INFO   14 /* requests scanline info, see VBVASCANLINEINFO below */
    853855
    854856/* host->guest commands */
    … …  
    10641066} VBVACAPS;
    10651067
     1068/* makes graphics device generate IRQ on VSYNC */
     1069#define VBVASCANLINECFG_ENABLE_VSYNC_IRQ        0x00000001
     1070/* guest driver may request the current scanline */
     1071#define VBVASCANLINECFG_ENABLE_SCANLINE_INFO    0x00000002
     1072/* request the current refresh period, returned in u32RefreshPeriodMs */
     1073#define VBVASCANLINECFG_QUERY_REFRESH_PERIOD    0x00000004
     1074/* set new refresh period specified in u32RefreshPeriodMs.
     1075 * if used with VBVASCANLINECFG_QUERY_REFRESH_PERIOD,
     1076 * u32RefreshPeriodMs is set to the previous refresh period on return */
     1077#define VBVASCANLINECFG_SET_REFRESH_PERIOD      0x00000008
     1078
     1079typedef struct VBVASCANLINECFG
     1080{
     1081    int32_t rc;
     1082    uint32_t fFlags;
     1083    uint32_t u32RefreshPeriodMs;
     1084    uint32_t u32Reserved;
     1085} VBVASCANLINECFG;
     1086
     1087typedef struct VBVASCANLINEINFO
     1088{
     1089    int32_t rc;
     1090    uint32_t u32ScreenId;
     1091    uint32_t u32InVBlank;
     1092    uint32_t u32ScanLine;
     1093} VBVASCANLINEINFO;
     1094
    10661095#pragma pack()
    10671096
    … …  
    11541183    VBOXVDMA_CTL_TYPE_ENABLE,
    11551184    VBOXVDMA_CTL_TYPE_DISABLE,
    1156     VBOXVDMA_CTL_TYPE_FLUSH
     1185    VBOXVDMA_CTL_TYPE_FLUSH,
     1186    VBOXVDMA_CTL_TYPE_WATCHDOG
    11571187} VBOXVDMA_CTL_TYPE;
    11581188

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk

    r41570 r41636  
    9090  VBoxVideoWddm_DEFS      += VBOX_WITH_CROGL
    9191 endif
     92 ifdef VBOX_VDMA_WITH_WATCHDOG
     93  VBoxVideoWddm_DEFS      += VBOX_VDMA_WITH_WATCHDOG
     94 endif
     95 
    9296 VBoxVideoWddm_INCS       += ../../../include .. . ../../../../common/VBoxGuestLib $(VBOX_PATH_CROGL_INCLUDE) $(VBOX_PATH_CROGL_GENFILES)
    9397 VBoxVideoWddm_LDFLAGS.x86 += /Entry:DriverEntry@8

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h

    r41337 r41636  
    116116   BOOL bNotifyDxDpc;
    117117
     118#ifdef VBOX_VDMA_WITH_WATCHDOG
     119   PKTHREAD pWdThread;
     120   KEVENT WdEvent;
     121#endif
     122
     123   KTIMER VSyncTimer;
     124   KDPC VSyncDpc;
     125
    118126#if 0
    119127   FAST_MUTEX ShRcTreeMutex;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp

    r41379 r41636  
    23652365    return Status;
    23662366}
     2367
     2368NTSTATUS vboxWddmThreadCreate(PKTHREAD * ppThread, PKSTART_ROUTINE pStartRoutine, PVOID pStartContext)
     2369{
     2370    NTSTATUS fStatus;
     2371    HANDLE hThread;
     2372    OBJECT_ATTRIBUTES fObjectAttributes;
     2373
     2374    Assert(KeGetCurrentIrql() == PASSIVE_LEVEL);
     2375
     2376    InitializeObjectAttributes(&fObjectAttributes, NULL, OBJ_KERNEL_HANDLE,
     2377                        NULL, NULL);
     2378
     2379    fStatus = PsCreateSystemThread(&hThread, THREAD_ALL_ACCESS,
     2380                        &fObjectAttributes, NULL, NULL,
     2381                        (PKSTART_ROUTINE) pStartRoutine, pStartContext);
     2382    if (!NT_SUCCESS(fStatus))
     2383      return fStatus;
     2384
     2385    ObReferenceObjectByHandle(hThread, THREAD_ALL_ACCESS, NULL,
     2386                        KernelMode, (PVOID*) ppThread, NULL);
     2387    ZwClose(hThread);
     2388    return STATUS_SUCCESS;
     2389}
     2390
     2391#ifdef VBOX_VDMA_WITH_WATCHDOG
     2392static int vboxWddmWdProgram(PVBOXMP_DEVEXT pDevExt, uint32_t cMillis)
     2393{
     2394    int rc = VINF_SUCCESS;
     2395    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     2396    if (pCmd)
     2397    {
     2398        pCmd->enmCtl = VBOXVDMA_CTL_TYPE_WATCHDOG;
     2399        pCmd->u32Offset = cMillis;
     2400        pCmd->i32Result = VERR_NOT_SUPPORTED;
     2401
     2402        const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pCmd);
     2403        Assert(pHdr);
     2404        if (pHdr)
     2405        {
     2406            do
     2407            {
     2408                HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pHdr);
     2409                Assert(offCmd != HGSMIOFFSET_VOID);
     2410                if (offCmd != HGSMIOFFSET_VOID)
     2411                {
     2412                    VBoxVideoCmnPortWriteUlong(VBoxCommonFromDeviceExt(pDevExt)->guestCtx.port, offCmd);
     2413                    rc = VBoxSHGSMICommandDoneSynch(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pHdr);
     2414                    AssertRC(rc);
     2415                    if (RT_SUCCESS(rc))
     2416                    {
     2417                        rc = pCmd->i32Result;
     2418                        AssertRC(rc);
     2419                    }
     2420                    break;
     2421                }
     2422                else
     2423                    rc = VERR_INVALID_PARAMETER;
     2424                /* fail to submit, cancel it */
     2425                VBoxSHGSMICommandCancelSynch(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pHdr);
     2426            } while (0);
     2427        }
     2428
     2429        VBoxSHGSMICommandFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pCmd);
     2430    }
     2431    else
     2432    {
     2433        LOGREL(("HGSMIHeapAlloc failed"));
     2434        rc = VERR_OUT_OF_RESOURCES;
     2435    }
     2436    return rc;
     2437}
     2438
     2439static uint32_t g_VBoxWdTimeout = 4000;
     2440/* if null g_VBoxWdTimeout / 2 is used */
     2441static uint32_t g_VBoxWdTimerPeriod = 0;
     2442
     2443static VOID vboxWddmWdThread(PVOID pvUser)
     2444{
     2445    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvUser;
     2446    BOOLEAN bExit = FALSE;
     2447    int rc;
     2448    while (1)
     2449    {
     2450        if (!bExit)
     2451        {
     2452            rc = vboxWddmWdProgram(pDevExt, g_VBoxWdTimeout /* ms */);
     2453            AssertRC(rc);
     2454        }
     2455        else
     2456        {
     2457            rc = vboxWddmWdProgram(pDevExt, 0 /* to disable WatchDog */);
     2458            AssertRC(rc);
     2459            break;
     2460        }
     2461        LARGE_INTEGER Timeout;
     2462        uint32_t timerTimeOut = g_VBoxWdTimerPeriod ? g_VBoxWdTimerPeriod : g_VBoxWdTimeout / 2;
     2463        Timeout.QuadPart = 10000ULL * timerTimeOut /* ms */;
     2464        NTSTATUS Status = KeWaitForSingleObject(&pDevExt->WdEvent, Executive, KernelMode, FALSE, &Timeout);
     2465        if (Status != STATUS_TIMEOUT)
     2466            bExit = TRUE;
     2467    }
     2468}
     2469
     2470NTSTATUS vboxWddmWdInit(PVBOXMP_DEVEXT pDevExt)
     2471{
     2472    KeInitializeEvent(&pDevExt->WdEvent, NotificationEvent, FALSE);
     2473
     2474    NTSTATUS Status = vboxWddmThreadCreate(&pDevExt->pWdThread, vboxWddmWdThread, pDevExt);
     2475    if (!NT_SUCCESS(Status))
     2476    {
     2477        WARN(("vboxWddmThreadCreate failed, Status 0x%x", Status));
     2478        pDevExt->pWdThread = NULL;
     2479    }
     2480    return Status;
     2481}
     2482
     2483NTSTATUS vboxWddmWdTerm(PVBOXMP_DEVEXT pDevExt)
     2484{
     2485    if (!pDevExt->pWdThread)
     2486        return STATUS_SUCCESS;
     2487
     2488    KeSetEvent(&pDevExt->WdEvent, 0, FALSE);
     2489
     2490    KeWaitForSingleObject(pDevExt->pWdThread, Executive, KernelMode, FALSE, NULL);
     2491    ObDereferenceObject(pDevExt->pWdThread);
     2492    pDevExt->pWdThread = NULL;
     2493    return STATUS_SUCCESS;
     2494}
     2495#endif
     2496
     2497static int vboxWddmSlConfigure(PVBOXMP_DEVEXT pDevExt, uint32_t fFlags)
     2498{
     2499    PHGSMIGUESTCOMMANDCONTEXT pCtx = &VBoxCommonFromDeviceExt(pDevExt)->guestCtx;
     2500    VBVASCANLINECFG *pCfg;
     2501    int rc = VINF_SUCCESS;
     2502
     2503    /* Allocate the IO buffer. */
     2504    pCfg = (VBVASCANLINECFG *)VBoxHGSMIBufferAlloc(pCtx,
     2505                                       sizeof (VBVASCANLINECFG), HGSMI_CH_VBVA,
     2506                                       VBVA_SCANLINE_CFG);
     2507
     2508    if (pCfg)
     2509    {
     2510        /* Prepare data to be sent to the host. */
     2511        pCfg->rc    = VERR_NOT_IMPLEMENTED;
     2512        pCfg->fFlags = fFlags;
     2513        rc = VBoxHGSMIBufferSubmit(pCtx, pCfg);
     2514        if (RT_SUCCESS(rc))
     2515        {
     2516            AssertRC(pCfg->rc);
     2517            rc = pCfg->rc;
     2518        }
     2519        /* Free the IO buffer. */
     2520        VBoxHGSMIBufferFree(pCtx, pCfg);
     2521    }
     2522    else
     2523        rc = VERR_NO_MEMORY;
     2524    return rc;
     2525}
     2526
     2527NTSTATUS VBoxWddmSlEnableVSyncNotification(PVBOXMP_DEVEXT pDevExt, BOOLEAN fEnable)
     2528{
     2529    if (!fEnable)
     2530    {
     2531        KeCancelTimer(&pDevExt->VSyncTimer);
     2532    }
     2533    else
     2534    {
     2535        LARGE_INTEGER DueTime;
     2536        DueTime.QuadPart = -166666LL; /* 60 Hz */
     2537        KeSetTimerEx(&pDevExt->VSyncTimer, DueTime, 17, &pDevExt->VSyncDpc);
     2538    }
     2539    return STATUS_SUCCESS;
     2540}
     2541
     2542NTSTATUS VBoxWddmSlGetScanLine(PVBOXMP_DEVEXT pDevExt, DXGKARG_GETSCANLINE *pGetScanLine)
     2543{
     2544    Assert((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pGetScanLine->VidPnTargetId);
     2545    VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[pGetScanLine->VidPnTargetId];
     2546    Assert(pTarget->HeightTotal);
     2547    Assert(pTarget->HeightVisible);
     2548    Assert(pTarget->HeightTotal > pTarget->HeightVisible);
     2549    Assert(pTarget->ScanLineState < pTarget->HeightTotal);
     2550    if (pTarget->HeightTotal)
     2551    {
     2552        uint32_t curScanLine = pTarget->ScanLineState;
     2553        ++pTarget->ScanLineState;
     2554        if (pTarget->ScanLineState >= pTarget->HeightTotal)
     2555            pTarget->ScanLineState = 0;
     2556
     2557
     2558        BOOL bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible);
     2559        pGetScanLine->ScanLine = curScanLine;
     2560        pGetScanLine->InVerticalBlank = bVBlank;
     2561    }
     2562    else
     2563    {
     2564        pGetScanLine->InVerticalBlank = TRUE;
     2565        pGetScanLine->ScanLine = 0;
     2566    }
     2567    return STATUS_SUCCESS;
     2568}
     2569
     2570static VOID vboxWddmSlVSyncDpc(
     2571  __in      struct _KDPC *Dpc,
     2572  __in_opt  PVOID DeferredContext,
     2573  __in_opt  PVOID SystemArgument1,
     2574  __in_opt  PVOID SystemArgument2
     2575)
     2576{
     2577    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)DeferredContext;
     2578    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
     2579    BOOLEAN bNeedDpc = FALSE;
     2580    for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     2581    {
     2582        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
     2583        PVBOXWDDM_ALLOCATION pPrimary = pSource->pPrimaryAllocation;
     2584        if (pPrimary && pPrimary->offVram != VBOXVIDEOOFFSET_VOID)
     2585        {
     2586            memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
     2587            notify.InterruptType = DXGK_INTERRUPT_CRTC_VSYNC;
     2588            /* @todo: !!!this is not correct in case we want source[i]->target[i!=j] mapping */
     2589            notify.CrtcVsync.VidPnTargetId = i;
     2590            notify.CrtcVsync.PhysicalAddress.QuadPart = pPrimary->offVram;
     2591            /* yes, we can report VSync at dispatch */
     2592            pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
     2593            bNeedDpc = TRUE;
     2594        }
     2595    }
     2596
     2597    if (bNeedDpc)
     2598    {
     2599        pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
     2600    }
     2601}
     2602
     2603NTSTATUS VBoxWddmSlInit(PVBOXMP_DEVEXT pDevExt)
     2604{
     2605    KeInitializeTimer(&pDevExt->VSyncTimer);
     2606    KeInitializeDpc(&pDevExt->VSyncDpc, vboxWddmSlVSyncDpc, pDevExt);
     2607    return STATUS_SUCCESS;
     2608}
     2609
     2610NTSTATUS VBoxWddmSlTerm(PVBOXMP_DEVEXT pDevExt)
     2611{
     2612    KeCancelTimer(&pDevExt->VSyncTimer);
     2613    return STATUS_SUCCESS;
     2614}

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h

    r41379 r41636  
    200200NTSTATUS vboxWddmDrvCfgInit(PUNICODE_STRING pRegStr);
    201201
     202#ifdef VBOX_VDMA_WITH_WATCHDOG
     203NTSTATUS vboxWddmWdInit(PVBOXMP_DEVEXT pDevExt);
     204NTSTATUS vboxWddmWdTerm(PVBOXMP_DEVEXT pDevExt);
     205#endif
     206
     207NTSTATUS VBoxWddmSlEnableVSyncNotification(PVBOXMP_DEVEXT pDevExt, BOOLEAN fEnable);
     208NTSTATUS VBoxWddmSlGetScanLine(PVBOXMP_DEVEXT pDevExt, DXGKARG_GETSCANLINE *pSl);
     209NTSTATUS VBoxWddmSlInit(PVBOXMP_DEVEXT pDevExt);
     210NTSTATUS VBoxWddmSlTerm(PVBOXMP_DEVEXT pDevExt);
     211
    202212#endif /* #ifndef ___VBoxMPMisc_h__ */

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r41533 r41636  
    28722872                {
    28732873                    PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_LOW);
    2874                     HGSMIClearHostGuestFlags(s->pHGSMI, HGSMIHOSTFLAGS_IRQ);
     2874                    HGSMIClearHostGuestFlags(s->pHGSMI, HGSMIHOSTFLAGS_IRQ
     2875#ifdef VBOX_VDMA_WITH_WATCHDOG
     2876                            | HGSMIHOSTFLAGS_WATCHDOG
     2877#endif
     2878                            | HGSMIHOSTFLAGS_VSYNC
     2879                            );
    28752880                }
    28762881                else
    … …  
    52565261    PVGASTATE pThis = (PVGASTATE)pvUser;
    52575262    NOREF(pDevIns);
     5263
     5264    if (pThis->fScanLineCfg & VBVASCANLINECFG_ENABLE_VSYNC_IRQ)
     5265    {
     5266        VBVARaiseIrq(pThis, HGSMIHOSTFLAGS_VSYNC);
     5267    }
    52585268
    52595269    if (pThis->pDrv)

  • trunk/src/VBox/Devices/Graphics/DevVGA.h

    r41541 r41636  
    413413     * adapter, the way it can handle async HGSMI command completion, etc. */
    414414    uint32_t                    fGuestCaps;
     415    uint32_t                    fScanLineCfg;
     416    uint8_t                     Padding10[4];
    415417#  else
    416     uint8_t                     Padding10[6];
     418    uint8_t                     Padding10[14];
    417419#  endif
    418420# endif /* VBOX_WITH_HGSMI */
    … …  
    481483bool VBVAIsEnabled(PVGASTATE pVGAState);
    482484
     485void VBVARaiseIrq (PVGASTATE pVGAState, uint32_t fFlags);
     486
    483487/* @return host-guest flags that were set on reset
    484488 * this allows the caller to make further cleaning when needed,

  • trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp

    r39887 r41636  
    16231623}
    16241624
     1625void VBVARaiseIrq (PVGASTATE pVGAState, uint32_t fFlags)
     1626{
     1627    PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
     1628    PDMCritSectEnter(&pVGAState->lock, VERR_SEM_BUSY);
     1629    HGSMISetHostGuestFlags(pVGAState->pHGSMI, HGSMIHOSTFLAGS_IRQ | fFlags);
     1630    PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
     1631    PDMCritSectLeave(&pVGAState->lock);
     1632}
     1633
    16251634/*
    16261635 *
    … …  
    16381647#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM))
    16391648    PVGASTATE pVGAState = (PVGASTATE)pvCallback;
    1640     PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
    1641     PDMCritSectEnter(&pVGAState->lock, VERR_SEM_BUSY);
    1642     HGSMISetHostGuestFlags(pVGAState->pHGSMI, HGSMIHOSTFLAGS_IRQ);
    1643     PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
    1644     PDMCritSectLeave(&pVGAState->lock);
     1649    VBVARaiseIrq (pVGAState, 0);
    16451650#else
    16461651    NOREF(pvCallback);
    … …  
    19691974        } break;
    19701975#endif
     1976        case VBVA_SCANLINE_CFG:
     1977        {
     1978            if (cbBuffer < sizeof (VBVASCANLINECFG))
     1979            {
     1980                rc = VERR_INVALID_PARAMETER;
     1981                break;
     1982            }
     1983
     1984            VBVASCANLINECFG *pCfg = (VBVASCANLINECFG*)pvBuffer;
     1985            pVGAState->fScanLineCfg = pCfg->fFlags;
     1986            pCfg->rc = VINF_SUCCESS;
     1987        } break;
    19711988        default:
    19721989            Log(("Unsupported VBVA guest command %d!!!\n",

  • trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp

    r41292 r41636  
    8383    PHGSMIINSTANCE pHgsmi;
    8484    PVGASTATE pVGAState;
     85#ifdef VBOX_VDMA_WITH_WATCHDOG
     86    PTMTIMERR3 WatchDogTimer;
     87#endif
    8588#ifdef VBOX_VDMA_WITH_WORKERTHREAD
    8689    VBOXVDMAPIPE Pipe;
    … …  
    10851088#endif
    10861089
     1090#ifdef VBOX_VDMA_WITH_WATCHDOG
     1091static DECLCALLBACK(void) vboxVDMAWatchDogTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
     1092{
     1093    VBOXVDMAHOST *pVdma = (VBOXVDMAHOST *)pvUser;
     1094    PVGASTATE pVGAState = pVdma->pVGAState;
     1095    VBVARaiseIrq(pVGAState, HGSMIHOSTFLAGS_WATCHDOG);
     1096}
     1097
     1098static int vboxVDMAWatchDogCtl(struct VBOXVDMAHOST *pVdma, uint32_t cMillis)
     1099{
     1100    PPDMDEVINS pDevIns = pVdma->pVGAState->pDevInsR3;
     1101    if (cMillis)
     1102        TMTimerSetMillies(pVdma->WatchDogTimer, cMillis);
     1103    else
     1104        TMTimerStop(pVdma->WatchDogTimer);
     1105    return VINF_SUCCESS;
     1106}
     1107#endif
     1108
    10871109int vboxVDMAConstruct(PVGASTATE pVGAState, uint32_t cPipeElements)
    10881110{
    … …  
    10981120        pVdma->pHgsmi = pVGAState->pHGSMI;
    10991121        pVdma->pVGAState = pVGAState;
     1122
     1123#ifdef VBOX_VDMA_WITH_WATCHDOG
     1124        rc = PDMDevHlpTMTimerCreate(pVGAState->pDevInsR3, TMCLOCK_REAL, vboxVDMAWatchDogTimer,
     1125                                    pVdma, TMTIMER_FLAGS_NO_CRIT_SECT,
     1126                                    "VDMA WatchDog Timer", &pVdma->WatchDogTimer);
     1127        AssertRC(rc);
     1128#endif
    11001129#ifdef VBOX_VDMA_WITH_WORKERTHREAD
    11011130        hgsmiListInit(&pVdma->PendingList);
    … …  
    12271256}
    12281257
    1229 
    12301258void vboxVDMAControl(struct VBOXVDMAHOST *pVdma, PVBOXVDMA_CTL pCmd, uint32_t cbCmd)
    12311259{
    … …  
    12441272            pCmd->i32Result = VINF_SUCCESS;
    12451273            break;
     1274#ifdef VBOX_VDMA_WITH_WATCHDOG
     1275        case VBOXVDMA_CTL_TYPE_WATCHDOG:
     1276            pCmd->i32Result = vboxVDMAWatchDogCtl(pVdma, pCmd->u32Offset);
     1277            break;
     1278#endif
    12461279        default:
    12471280            AssertBreakpoint();

  • trunk/src/VBox/Devices/Makefile.kmk

    r41477 r41636  
    254254        Graphics/DevVGA_VDMA.cpp
    255255 endif
     256 
     257 ifdef VBOX_VDMA_WITH_WATCHDOG
     258  VBoxDD_DEFS           += VBOX_VDMA_WITH_WATCHDOG
     259 endif
    256260
    257261 ifdef VBOX_WITH_PXE_ROM
    … …  
    829833   VBoxDDGC_DEFS        += VBOX_WITH_CRHGSMI
    830834  endif
    831 
    832835  ifdef VBOXWDDM_WITH_VBVA
    833836   VBoxDDGC_DEFS        += VBOXWDDM_WITH_VBVA
     837  endif
     838  ifdef VBOX_VDMA_WITH_WATCHDOG
     839   VBoxDDGC_DEFS        += VBOX_VDMA_WITH_WATCHDOG
    834840  endif
    835841
    … …  
    977983  VBoxDDR0_DEFS         += VBOXWDDM_WITH_VBVA
    978984 endif
     985 ifdef VBOX_VDMA_WITH_WATCHDOG
     986  VBoxDDR0_DEFS        += VBOX_VDMA_WITH_WATCHDOG
     987 endif
    979988
    980989 ifdef VBOX_WITH_VUSB
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette