VirtualBox

Changeset 27984 in vbox


Ignore:
Timestamp:
Apr 5, 2010 1:28:29 PM (15 years ago)
Author:
vboxsync
Message:

wddm: more impl for autoresize support

Location:
trunk/src/VBox/Additions/WINNT
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp

    r27976 r27984  
    12391239 */
    12401240VOID VBoxWddmGetModesTable(PDEVICE_EXTENSION DeviceExtension, bool bRebuildTable,
    1241         VIDEO_MODE_INFORMATION ** ppModes, uint32_t * pcModes, uint32_t * pPreferrableMode,
     1241        VIDEO_MODE_INFORMATION ** ppModes, uint32_t * pcModes, int32_t * pPreferrableMode,
    12421242        D3DKMDT_2DREGION **ppResolutions, uint32_t * pcResolutions)
    12431243{
    … …  
    12501250    *ppModes = VideoModes;
    12511251    *pcModes = gNumVideoModes;
    1252     *pPreferrableMode = gPreferredVideoMode;
     1252    *pPreferrableMode = (int32_t)gPreferredVideoMode;
    12531253    *ppResolutions = g_VBoxWddmVideoResolutions;
    12541254    *pcResolutions = g_VBoxWddmNumResolutions;
    … …  
    12581258{
    12591259    g_bModesTableInitialized = false;
     1260}
     1261
     1262NTSTATUS VBoxWddmGetModesForResolution(PDEVICE_EXTENSION DeviceExtension, bool bRebuildTable,
     1263        D3DKMDT_2DREGION *pResolution,
     1264        VIDEO_MODE_INFORMATION * pModes, uint32_t cModes, uint32_t *pcModes, int32_t *piPreferrableMode)
     1265{
     1266    VIDEO_MODE_INFORMATION *pAllModes;
     1267    uint32_t cAllModes, cAllResolutions;
     1268    int32_t iPreferrableMode;
     1269    D3DKMDT_2DREGION *pAllResolutions;
     1270    VBoxWddmGetModesTable(DeviceExtension, bRebuildTable,
     1271            &pAllModes, &cAllModes, &iPreferrableMode,
     1272            &pAllResolutions, &cAllResolutions);
     1273    NTSTATUS Status = STATUS_SUCCESS;
     1274    uint32_t cFound = 0;
     1275    int iFoundPreferrableMode = -1;
     1276    for (uint32_t i = 0; i < cAllModes; ++i)
     1277    {
     1278        VIDEO_MODE_INFORMATION *pCur = &pAllModes[i];
     1279        if (pResolution->cx == pAllModes[iPreferrableMode].VisScreenWidth
     1280                        && pResolution->cy == pAllModes[iPreferrableMode].VisScreenHeight)
     1281        {
     1282            if (pModes && cModes > cFound)
     1283            {
     1284                memcpy(&pModes[cFound], pCur, sizeof (VIDEO_MODE_INFORMATION));
     1285                ++pModes;
     1286            }
     1287            else
     1288                Status = STATUS_BUFFER_TOO_SMALL;
     1289            ++cFound;
     1290
     1291            if (i == (uint32_t)iPreferrableMode)
     1292                iFoundPreferrableMode = i;
     1293        }
     1294    }
     1295    *pcModes = cFound;
     1296    if (piPreferrableMode)
     1297        *piPreferrableMode = iFoundPreferrableMode;
     1298    return Status;
    12601299}
    12611300

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h

    r27955 r27984  
    584584
    585585VOID VBoxWddmGetModesTable(PDEVICE_EXTENSION DeviceExtension, bool bRebuildTable,
    586         VIDEO_MODE_INFORMATION ** ppModes, uint32_t * pcModes, uint32_t * pPreferrableMode,
     586        VIDEO_MODE_INFORMATION ** ppModes, uint32_t * pcModes, int32_t * pPreferrableMode,
    587587        D3DKMDT_2DREGION **ppResolutions, uint32_t * pcResolutions);
    588588
    589589VOID VBoxWddmInvalidateModesTable(PDEVICE_EXTENSION DeviceExtension);
     590
     591/* @return STATUS_BUFFER_TOO_SMALL - if buffer is too small, STATUS_SUCCESS - on success */
     592NTSTATUS VBoxWddmGetModesForResolution(PDEVICE_EXTENSION DeviceExtension, bool bRebuildTable,
     593        D3DKMDT_2DREGION *pResolution,
     594        VIDEO_MODE_INFORMATION * pModes, uint32_t cModes, uint32_t *pcModes, int32_t * piPreferrableMode);
    590595
    591596D3DDDIFORMAT vboxWddmCalcPixelFormat(VIDEO_MODE_INFORMATION *pInfo);

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVidPn.cpp

    r27547 r27984  
    527527        VIDEO_MODE_INFORMATION *pModes,
    528528        uint32_t cModes,
    529         uint32_t iPreferredMode)
     529        int iPreferredMode)
    530530{
    531531    NTSTATUS Status = STATUS_SUCCESS;
    … …  
    546546                if (Status == STATUS_SUCCESS)
    547547                {
    548 //                    if (iPreferredMode == i)
    549 //                    {
    550 //                        Status = pNewVidPnSourceModeSetInterface->pfnPinMode(hNewVidPnSourceModeSet, modeId);
    551 //                        Assert(Status == STATUS_SUCCESS);
    552 //                        if (Status != STATUS_SUCCESS)
    553 //                        {
    554 //                            drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
    555 //                            /* don't treat it as fatal */
    556 //                            Status = STATUS_SUCCESS;
    557 //                        }
    558 //                    }
     548                    if (iPreferredMode == i)
     549                    {
     550                        AssertBreakpoint();
     551                        Status = pNewVidPnSourceModeSetInterface->pfnPinMode(hNewVidPnSourceModeSet, modeId);
     552                        Assert(Status == STATUS_SUCCESS);
     553                        if (Status != STATUS_SUCCESS)
     554                        {
     555                            drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
     556                            /* don't treat it as fatal */
     557                            Status = STATUS_SUCCESS;
     558                        }
     559                    }
    559560                }
    560561                else
    … …  
    602603        BOOLEAN bPreferred)
    603604{
     605    Assert(!bPreferred);
    604606    pNewVidPnTargetModeInfo->Preference = bPreferred ? D3DKMDT_MP_PREFERRED : D3DKMDT_MP_NOTPREFERRED;
    605607
    606608    return vboxVidPnPopulateVideoSignalInfo(&pNewVidPnTargetModeInfo->VideoSignalInfo, pResolution, 60 /* ULONG VSync */);
    607609}
     610
     611#define VBOXVIDPN_MODESET_NO_PIN_PREFERRED  0x00000001
     612#define VBOXVIDPN_MODESET_MARK_PREFERRED    0x00000002
    608613
    609614NTSTATUS vboxVidPnPopulateTargetModeSetFromLegacy(PDEVICE_EXTENSION pDevExt,
    … …  
    612617        D3DKMDT_2DREGION *pResolutions,
    613618        uint32_t cResolutions,
    614         VIDEO_MODE_INFORMATION *pPreferredMode)
     619        VIDEO_MODE_INFORMATION *pPreferredMode,
     620        uint32_t fFlags)
    615621{
    616622    NTSTATUS Status = STATUS_SUCCESS;
    … …  
    623629        {
    624630            bool bPreferred = pPreferredMode ? pPreferredMode->VisScreenHeight == pResolutions[i].cx
    625                     && pPreferredMode->VisScreenWidth == pResolutions[i].cy : TRUE;
    626             Status = vboxVidPnPopulateTargetModeInfoFromLegacy(pNewVidPnTargetModeInfo, &pResolutions[i], bPreferred);
     631                    && pPreferredMode->VisScreenWidth == pResolutions[i].cy : FALSE;
     632            Status = vboxVidPnPopulateTargetModeInfoFromLegacy(pNewVidPnTargetModeInfo, &pResolutions[i], bPreferred && (fFlags & VBOXVIDPN_MODESET_MARK_PREFERRED));
    627633            Assert(Status == STATUS_SUCCESS);
    628634            if (Status == STATUS_SUCCESS)
    … …  
    633639                if (Status == STATUS_SUCCESS)
    634640                {
    635 //                    if (bPreferred)
    636 //                    {
    637 //                        Status = pNewVidPnTargetModeSetInterface->pfnPinMode(hNewVidPnTargetModeSet, modeId);
    638 //                        Assert(Status == STATUS_SUCCESS);
    639 //                        if (Status != STATUS_SUCCESS)
    640 //                        {
    641 //                            drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
    642 //                            /* don't treat it as fatal */
    643 //                            Status = STATUS_SUCCESS;
    644 //                        }
    645 //                    }
     641                    if (bPreferred && !(fFlags & VBOXVIDPN_MODESET_NO_PIN_PREFERRED))
     642                    {
     643                        AssertBreakpoint();
     644                        Status = pNewVidPnTargetModeSetInterface->pfnPinMode(hNewVidPnTargetModeSet, modeId);
     645                        Assert(Status == STATUS_SUCCESS);
     646                        if (Status != STATUS_SUCCESS)
     647                        {
     648                            drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
     649                            /* don't treat it as fatal */
     650                            Status = STATUS_SUCCESS;
     651                        }
     652                    }
    646653                }
    647654                else
    … …  
    665672NTSTATUS vboxVidPnCreatePopulateSourceModeSetFromLegacy(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
    666673                    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId,
    667                     VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, uint32_t iPreferredMode)
     674                    VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iPreferredMode)
    668675{
    669676    D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet;
    … …  
    707714                    D3DKMDT_2DREGION *pResolutions,
    708715                    uint32_t cResolutions,
    709                     VIDEO_MODE_INFORMATION *pPreferredMode)
     716                    VIDEO_MODE_INFORMATION *pPreferredMode, uint32_t fFlags)
    710717{
    711718    D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet;
    … …  
    720727        Status = vboxVidPnPopulateTargetModeSetFromLegacy(pDevExt,
    721728                    hNewVidPnTargetModeSet, pNewVidPnTargetModeSetInterface,
    722                     pResolutions, cResolutions, pPreferredMode);
     729                    pResolutions, cResolutions, pPreferredMode, fFlags);
    723730        Assert(Status == STATUS_SUCCESS);
    724731        if (Status == STATUS_SUCCESS)
    … …  
    747754
    748755NTSTATUS vboxVidPnCreatePopulateVidPnFromLegacy(PDEVICE_EXTENSION pDevExt, D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
    749         VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, uint32_t iPreferredMode,
     756        VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iPreferredMode,
    750757        D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions)
    751758{
    … …  
    753760    D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology;
    754761    const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
     762    VIDEO_MODE_INFORMATION *pPreferredMode = iPreferredMode >= 0 ? &pModes[iPreferredMode] : NULL;
    755763    Status = pVidPnInterface->pfnGetTopology(hVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
    756764    if (Status == STATUS_SUCCESS)
    … …  
    798806                {
    799807                    Status = vboxVidPnCreatePopulateTargetModeSetFromLegacy(pDevExt, hVidPn, pVidPnInterface, 0,
    800                             pResolutions, cResolutions, &pModes[iPreferredMode]);
     808                            pResolutions, cResolutions, pPreferredMode, 0);
    801809                    Assert(Status == STATUS_SUCCESS);
    802810                    if (Status != STATUS_SUCCESS)
    … …  
    835843    VIDEO_MODE_INFORMATION *pModes = pCbContext->pModes;
    836844    uint32_t cModes = pCbContext->cModes;
    837     uint32_t iPreferredMode = pCbContext->iPreferredMode;
     845    int iPreferredMode = pCbContext->iPreferredMode;
    838846    uint32_t cResolutions = pCbContext->cResolutions;
    839847    D3DKMDT_2DREGION * pResolutions = pCbContext->pResolutions;
    … …  
    870878    D3DKMDT_HVIDPNSOURCEMODESET hCurVidPnSourceModeSet;
    871879    const DXGK_VIDPNSOURCEMODESET_INTERFACE *pCurVidPnSourceModeSetInterface;
     880    VIDEO_MODE_INFORMATION *pPreferredMode = iPreferredMode >= 0 ? &pModes[iPreferredMode] : NULL;
    872881
    873882    Status = pVidPnInterface->pfnAcquireSourceModeSet(hDesiredVidPn,
    … …  
    933942                                    {
    934943                                        D3DKMDT_VIDPN_TARGET_MODE dummyMode = {0};
    935                                         Status = vboxVidPnPopulateTargetModeInfoFromLegacy(&dummyMode, &Resolution, TRUE);
     944                                        Status = vboxVidPnPopulateTargetModeInfoFromLegacy(&dummyMode, &Resolution, FALSE);
    936945                                        Assert(Status == STATUS_SUCCESS);
    937946                                        if (Status == STATUS_SUCCESS)
    … …  
    963972                                            &Resolution,
    964973                                            1,
    965                                             NULL);
     974                                            pPreferredMode,
     975                                            0);
    966976                                    Assert(Status == STATUS_SUCCESS);
    967977                                    if (Status != STATUS_SUCCESS)
    … …  
    9971007                                pResolutions,
    9981008                                cResolutions,
    999                                 &pModes[iPreferredMode]);
     1009                                pPreferredMode,
     1010                                0);
    10001011                        Assert(Status == STATUS_SUCCESS);
    10011012                        if (Status != STATUS_SUCCESS)

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVidPn.h

    r27239 r27984  
    4646    /* legacy mode information populated by the common XPDM-WDDM layer */
    4747    uint32_t cModes;
    48     uint32_t iPreferredMode;
     48    int iPreferredMode;
    4949    VIDEO_MODE_INFORMATION *pModes;
    5050    uint32_t cResolutions;
    … …  
    114114
    115115NTSTATUS vboxVidPnCreatePopulateVidPnFromLegacy(struct _DEVICE_EXTENSION* pDevExt, D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
    116         VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, uint32_t iPreferredMomde,
     116        VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iPreferredMomde,
    117117        D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions);
    118118

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

    r27955 r27984  
    24172417    NTSTATUS Status;
    24182418    uint32_t cModes;
    2419     uint32_t iPreferredMode;
     2419    int iPreferredMode;
    24202420    VIDEO_MODE_INFORMATION *pModes;
    24212421    uint32_t cResolutions;
    24222422    D3DKMDT_2DREGION *pResolutions;
     2423    VIDEO_MODE_INFORMATION ModeInfos[4];
     2424    VIDEO_MODE_INFORMATION *pModeInfos;
     2425    D3DKMDT_2DREGION Resolution;
     2426    uint32_t cModeInfos;
     2427    int32_t iPreferredModeInfo;
     2428    bool bFreeModes = false;
    24232429    VBoxWddmGetModesTable(pDevExt, /* PDEVICE_EXTENSION DeviceExtension */
    24242430            false, /* bool bRebuildTable*/
    … …  
    24282434            &pResolutions, /* D3DKMDT_2DREGION **ppResolutions */
    24292435            &cResolutions /* uint32_t * pcResolutions */);
    2430 
    2431 
    2432     const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
    2433     Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
    2434     Assert(Status == STATUS_SUCCESS);
     2436    Resolution.cx = pModes[iPreferredMode].VisScreenWidth;
     2437    Resolution.cy = pModes[iPreferredMode].VisScreenHeight;
     2438    Status = VBoxWddmGetModesForResolution(pDevExt, false,
     2439            &Resolution,
     2440            ModeInfos, RT_ELEMENTS(ModeInfos), &cModeInfos, &iPreferredModeInfo);
     2441    Assert(Status == STATUS_SUCCESS || Status == STATUS_BUFFER_TOO_SMALL);
    24352442    if (Status == STATUS_SUCCESS)
    2436     {
    2437         D3DKMDT_2DREGION PrefRegion;
    2438         PrefRegion.cx = pModes[iPreferredMode].VisScreenHeight;
    2439         PrefRegion.cy = pModes[iPreferredMode].VisScreenWidth;
    2440         Status = vboxVidPnCreatePopulateVidPnFromLegacy(pDevExt, pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pVidPnInterface,
    2441 #if 0
    2442                 pModes, cModes, iPreferredMode,
    2443                 pResolutions, cResolutions
    2444 #else
    2445                 &pModes[iPreferredMode], 1, 0,
    2446                 &PrefRegion, 1
    2447 #endif
    2448                 );
     2443        pModeInfos = ModeInfos;
     2444    else if (Status == STATUS_BUFFER_TOO_SMALL)
     2445    {
     2446        uint32_t cModeInfos2;
     2447        pModeInfos = (VIDEO_MODE_INFORMATION*)vboxWddmMemAlloc(sizeof (VIDEO_MODE_INFORMATION) * cModeInfos);
     2448        if (pModeInfos)
     2449        {
     2450            bFreeModes = true;
     2451            Status = VBoxWddmGetModesForResolution(pDevExt, false,
     2452                    &Resolution,
     2453                    pModeInfos, cModeInfos, &cModeInfos2, &iPreferredModeInfo);
     2454            Assert(Status == STATUS_SUCCESS);
     2455            Assert(iPreferredModeInfo >= 0); /* the array should contain the preffered info */
     2456            if (Status != STATUS_SUCCESS)
     2457                drprintf((__FUNCTION__": second call to VBoxWddmGetModesForResolution failed Status(0x%x), cModeInfos(%d), cModeInfos2(%d)\n", Status, cModeInfos, cModeInfos2));
     2458        }
     2459    }
     2460    else
     2461        drprintf((__FUNCTION__": VBoxWddmGetModesForResolution failed Status(0x%x)\n", Status));
     2462
     2463    if (Status == STATUS_SUCCESS)
     2464    {
     2465        const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
     2466        Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pVidPnInterface);
    24492467        Assert(Status == STATUS_SUCCESS);
    2450         if (Status != STATUS_SUCCESS)
    2451             drprintf((__FUNCTION__": vboxVidPnCreatePopulateVidPnFromLegacy failed Status(0x%x)\n", Status));
    2452     }
    2453     else
    2454         drprintf((__FUNCTION__": DxgkCbQueryVidPnInterface failed Status(0x%x)\n", Status));
     2468        if (Status == STATUS_SUCCESS)
     2469        {
     2470            Assert (iPreferredModeInfo >= 0);
     2471            Status = vboxVidPnCreatePopulateVidPnFromLegacy(pDevExt, pRecommendFunctionalVidPnArg->hRecommendedFunctionalVidPn, pVidPnInterface,
     2472                    pModeInfos, cModeInfos, iPreferredModeInfo,
     2473                    &Resolution, 1);
     2474            Assert(Status == STATUS_SUCCESS);
     2475            if (Status != STATUS_SUCCESS)
     2476                drprintf((__FUNCTION__": vboxVidPnCreatePopulateVidPnFromLegacy failed Status(0x%x)\n", Status));
     2477        }
     2478        else
     2479            drprintf((__FUNCTION__": DxgkCbQueryVidPnInterface failed Status(0x%x)\n", Status));
     2480    }
     2481
     2482    if (bFreeModes)
     2483        vboxWddmMemFree(pModeInfos);
    24552484
    24562485    dfprintf(("<== "__FUNCTION__ ", status(0x%x), context(0x%x)\n", Status, hAdapter));
    … …  
    24942523                    &CbContext.cResolutions /* uint32_t * pcResolutions */);
    24952524            Assert(CbContext.cModes);
    2496             Assert(CbContext.cModes > CbContext.iPreferredMode);
     2525            Assert(CbContext.cModes > (uint32_t)CbContext.iPreferredMode);
     2526            CbContext.iPreferredMode = -1; /* <- we do not want the modes to be pinned */
    24972527            Status = vboxVidPnEnumPaths(pContext, pEnumCofuncModalityArg->hConstrainingVidPn, pVidPnInterface,
    24982528                    hVidPnTopology, pVidPnTopologyInterface,
    … …  
    27372767    NTSTATUS Status;
    27382768    uint32_t cModes;
    2739     uint32_t iPreferredMode;
     2769    int32_t iPreferredMode;
    27402770    VIDEO_MODE_INFORMATION *pModes;
    27412771    uint32_t cResolutions;
    … …  
    27612791                    &pResolutions[i],
    27622792                    D3DKMDT_MCO_DRIVER,
    2763                     true);
     2793                    FALSE);
    27642794            Assert(Status == STATUS_SUCCESS);
    27652795            if (Status == STATUS_SUCCESS)

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxTray.h

    r27955 r27984  
    6969    /* with WDDM the approach is to call into WDDM miniport driver via PFND3DKMT API provided by the GDI,
    7070     * The PFND3DKMT is supposed to be used by the OpenGL ICD according to MSDN, so this approach is a bit hacky */
    71     /* open adapter */
    7271    union
    7372    {
    7473        struct
    7574        {
    76         PFND3DKMT_OPENADAPTERFROMHDC pfnD3DKMTOpenAdapterFromHdc;
    77         PFND3DKMT_OPENADAPTERFROMGDIDISPLAYNAME pfnD3DKMTOpenAdapterFromGdiDisplayName;
    78         /* close adapter */
    79         PFND3DKMT_CLOSEADAPTER pfnD3DKMTCloseAdapter;
    80         /* escape */
    81         PFND3DKMT_ESCAPE pfnD3DKMTEscape;
     75            /* open adapter */
     76            PFND3DKMT_OPENADAPTERFROMHDC pfnD3DKMTOpenAdapterFromHdc;
     77            PFND3DKMT_OPENADAPTERFROMGDIDISPLAYNAME pfnD3DKMTOpenAdapterFromGdiDisplayName;
     78            /* close adapter */
     79            PFND3DKMT_CLOSEADAPTER pfnD3DKMTCloseAdapter;
     80            /* escape */
     81            PFND3DKMT_ESCAPE pfnD3DKMTEscape;
     82            PFND3DKMT_INVALIDATEACTIVEVIDPN pfnD3DKMTInvalidateActiveVidPn;
    8283        } wddm;
    8384    } modeData;
Note: See TracChangeset for help on using the changeset viewer.

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