osd_osi.c

IBM source for pallas/vulcan/vesta

        }
        break;
        
    case GFX_VDEV_OSDIMG:
        if(!(pSurface->uPlaneConfig & OSD_PLANE_IMAGE))
        {
            PDEBUG("Surface is incompatible with still device!\n");
            return -1;
        }
        break;
        
    default:    // we could not attach it to null device
        PDEBUG("Invalid device ID!\n");
        return -1;
    }
    
    /////////////////////////
    if(os_get_mutex(gOSDMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }
    
    pSurface->pNextAttach = gOSDDev[graphDev].pSurface;
    pSurface->attachedDev = graphDev;
    gOSDDev[graphDev].pSurface = pSurface;
    
    __update_device_surface(graphDev, pSurface);

    if(GFX_VDEV_OSDGFX == graphDev && !gOSDDev[GFX_VDEV_OSDIMG].pSurface && !pSurface->twinheader)
         osd_atom_set_plane_control(OSD_PLANE_A_DISABLE, OSD_PLANE_IMAGE);   // should we ?

    os_release_mutex(gOSDMutex);
    /////////////////////////

    PDEBUG("Success!\n");

    return 0;
}


// pSurface can be NULL to detach default surface 
INT osd_osi_detach_comp_gfx_surface(GFX_VISUAL_DEVICE_ID_T graphDev, GFX_SURFACE_T * pSurface)
{
    int updateSurface = 0;
    int twinheader = 0;

    if( GFX_VDEV_NULL == graphDev || 
        (pSurface && (   !gfx_osi_pSurface_alloc(pSurface)  // psurface can be NULL
                      || pSurface->attachedDev != graphDev) ))
    {
        PDEBUG("Invalid parameter or uninitialized surface!\n");
        return -1;    // we cann't do it
    }

    if(!pSurface)   // if it is NULL, detach the top most surface
        pSurface = gOSDDev[graphDev].pSurface;

    if(!(gOSDDev[graphDev].uAttr & __OSD_GRAPH_DEVICE_INIT)) 
    {
        PDEBUG("Device %d is not initlized!\n", (INT)graphDev);
        return -1;
    }

    /////////////////////////
    if(os_get_mutex(gOSDMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }


    // detach 
    if(gOSDDev[graphDev].pSurface)
    {
        GFX_SURFACE_T *pCurr = gOSDDev[graphDev].pSurface;
        GFX_SURFACE_T *pPrev = NULL;
        // look it up
        while(pCurr && pCurr != pSurface) 
        {
            pPrev = pCurr;
            pCurr = pCurr->pNextAttach;
        }
        if(!pCurr)  // not find
        {
            os_release_mutex(gOSDMutex);
            /////////////////////////
            PDEBUG("Surface 0x%8.8x is not attached to device %d!\n", (INT)pSurface, (INT)graphDev);
            return -1;
        }

        pCurr->attachedDev = GFX_VDEV_NULL;
        if(pCurr == gOSDDev[graphDev].pSurface) //  the top most one
        {
            updateSurface = 1;
            if(GFX_VDEV_OSDGFX == graphDev && gOSDDev[graphDev].pSurface->twinheader) twinheader = 1;
            gOSDDev[graphDev].pSurface = pCurr->pNextAttach;
        }
        else // we don't need to update the surface
        {
            // pPrev should never be NULL at this point
            pPrev->pNextAttach = pCurr->pNextAttach;
        }
        pCurr->pNextAttach = NULL; // done
    }
    else
    {
        os_release_mutex(gOSDMutex);
        /////////////////////////
        PDEBUG("Device %d doesn't have a surface attached!\n", (INT)graphDev);
        return -1;
    }

    if(updateSurface)
    {
        if(NULL == gOSDDev[graphDev].pSurface)  // no one attached, so shutdown
        {
            switch(graphDev)
            {
            case GFX_VDEV_OSDCUR:
                osd_atom_set_plane_control(OSD_PLANE_A_DISABLE, OSD_PLANE_CURSOR);
                break;
                
            case GFX_VDEV_OSDGFX:
                osd_atom_set_plane_control(OSD_PLANE_A_DISABLE, OSD_PLANE_GRAPHICS);
                osd_atom_set_display_control(OSD_CNTL_E32BCO, 0);   // certainly
                if(gOSDDev[GFX_VDEV_OSDIMG].pSurface)
                    __update_device_surface(GFX_VDEV_OSDGFX, gOSDDev[GFX_VDEV_OSDGFX].pSurface);
                else
                    osd_atom_set_plane_control(OSD_PLANE_A_DISABLE, OSD_PLANE_IMAGE);   // should we ?
                break;
                
            case GFX_VDEV_OSDIMG:
                osd_atom_set_plane_control(OSD_PLANE_A_DISABLE, OSD_PLANE_IMAGE);
                if(gOSDDev[GFX_VDEV_OSDGFX].pSurface && gOSDDev[GFX_VDEV_OSDGFX].pSurface->twinheader)   // we need to update this for twinheader ones
                    __update_device_surface(GFX_VDEV_OSDGFX, gOSDDev[GFX_VDEV_OSDGFX].pSurface);
                break;
                
            default:
                PDEBUG("Invalid device ID!\n");
            }
        }
        else    // update the current surface
        {
            if(twinheader && gOSDDev[GFX_VDEV_OSDIMG].pSurface) 
                __update_device_surface(GFX_VDEV_OSDIMG, gOSDDev[GFX_VDEV_OSDIMG].pSurface);
            __update_device_surface(graphDev, gOSDDev[graphDev].pSurface);
        }
    }
    os_release_mutex(gOSDMutex);
    /////////////////////////

    PDEBUG("Success!\n");
    return 0;
}

INT osd_osi_set_device_parm(GFX_VISUAL_DEVICE_ID_T graphDev, OSD_GRAPH_DEVICE_PARM_T parm, UINT uValue)
{
    INT rtn;
    UINT uPlane=0;
    if(!(gOSDDev[graphDev].uAttr & __OSD_GRAPH_DEVICE_INIT)) 
    {
        PDEBUG("Device %d is not initlized!\n", (INT)graphDev);
        return -1;
    }

    switch(graphDev)
    {
    case GFX_VDEV_OSDCUR:
        uPlane = OSD_PLANE_CURSOR;
        break;

    case GFX_VDEV_OSDGFX:
        uPlane = OSD_PLANE_GRAPHICS;
        break;

    case GFX_VDEV_OSDIMG:
        uPlane = OSD_PLANE_IMAGE;
        break;

    default:
        PDEBUG("Invalid device ID!\n");
        os_release_mutex(gOSDMutex);
        /////////////////////////
        return -1;
    }

    /////////////////////////
    if(os_get_mutex(gOSDMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }
    switch(parm)
    {
    case OSD_GRAPH_DEVICE_ENABLE:    //   0x001 enable / 0x000 disable
        rtn = osd_atom_set_plane_control(uValue ? OSD_PLANE_A_ENABLE : OSD_PLANE_A_DISABLE, uPlane);
        break;

    default:
        rtn = -1;
        break;
    }

    os_release_mutex(gOSDMutex);
    /////////////////////////
    return rtn;
}

UINT osd_osi_get_device_parm(GFX_VISUAL_DEVICE_ID_T graphDev, OSD_GRAPH_DEVICE_PARM_T parm)
{
    UINT rtn;
    UINT uPlane=0;
    if(!(gOSDDev[graphDev].uAttr & __OSD_GRAPH_DEVICE_INIT)) 
    {
        PDEBUG("Device %d is not initlized!\n", (INT)graphDev);
        return 0;
    }

    switch(graphDev)
    {
    case GFX_VDEV_OSDCUR:
        uPlane = OSD_PLANE_CURSOR;
        break;

    case GFX_VDEV_OSDGFX:
        uPlane = OSD_PLANE_GRAPHICS;
        break;

    case GFX_VDEV_OSDIMG:
        uPlane = OSD_PLANE_IMAGE;
        break;

    default:
        PDEBUG("Invalid device ID!\n");
        os_release_mutex(gOSDMutex);
        /////////////////////////
        return 0;
    }

    /////////////////////////
    if(os_get_mutex(gOSDMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return 0;
    }
    switch(parm)
    {
    case OSD_GRAPH_DEVICE_ENABLE:    //   0x001 enable / 0x000 disable
        rtn = osd_atom_get_plane_control(OSD_PLANE_A_ENABLE, uPlane);
        break;
    default:
        rtn = 0;
        break;
    }

    os_release_mutex(gOSDMutex);
    /////////////////////////
    return rtn;
}


INT osd_osi_set_display_parm(OSD_DISPLAY_CONTROL_T parm, UINT uAttr)
{
    INT rtn;
    /////////////////////////
    if(os_get_mutex(gOSDMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }

    switch(parm)
    {
    case OSD_DISP_CNTL_BACKCOLOR:  // 16 bit back color
        rtn = osd_atom_set_display_control(OSD_CNTL_BACKCOLOR, uAttr);
        break;

    case OSD_DISP_CNTL_AFVP:      // Anti-flicker video plane, 0 disable, 1 enable
        rtn = osd_atom_set_display_control(OSD_CNTL_AFVP, uAttr);
        break;

    case OSD_DISP_CNTL_EDAF:      // Enable display anti-flicker, 0 disable, 1 enable
        rtn = osd_atom_set_display_control(OSD_CNTL_EDAF, uAttr);
        break;

    case OSD_DISP_CNTL_AFDT:      // Anti-flicker detection threshold, 2 bits attr
        rtn = osd_atom_set_display_control(OSD_CNTL_AFDT, uAttr);
        break;

    case OSD_DISP_CNTL_VPAFC:     // Video plane anti-flicker correction, 2 bits attr
        rtn = osd_atom_set_display_control(OSD_CNTL_VPAFC, uAttr);
        break;

    case OSD_DISP_CNTL_ANIM:     // Animation mode, 0 no, 1 yes -- BJC 102102
        rtn = osd_atom_set_display_control(OSD_CNTL_ANIM, uAttr);
        break;

    case OSD_DISP_CNTL_ANIMR:    // Animation rate, 3 bits attr -- BJC 102102
        rtn = osd_atom_set_display_control(OSD_CNTL_ANIMR, uAttr);
        break;

    case OSD_DISP_CNTL_CHFSR:    // Custom horizontal FIR scaling ratio, 9 bits attr -- BJC 102102
        rtn = osd_atom_set_display_control(OSD_CNTL_CHFSR, uAttr);
        break;

    default:
        rtn = -1;
        break;
    }
    
    os_release_mutex(gOSDMutex);
    /////////////////////////

    return rtn;
}


UINT osd_osi_get_display_parm(OSD_DISPLAY_CONTROL_T parm)
{
    UINT rtn;
    /////////////////////////
    if(os_get_mutex(gOSDMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return 0;
    }

    switch(parm)
    {
    case OSD_DISP_CNTL_BACKCOLOR:  // 16 bit back color
        rtn = osd_atom_get_display_control(OSD_CNTL_BACKCOLOR);
        break;

    case OSD_DISP_CNTL_AFVP:      // Anti-flicker video plane, 0 disable, 1 enable
        rtn = osd_atom_get_display_control(OSD_CNTL_AFVP);
        break;

    case OSD_DISP_CNTL_EDAF:      // Enable display anti-flicker, 0 disable, 1 enable
        rtn = osd_atom_get_display_control(OSD_CNTL_EDAF);
        break;

    case OSD_DISP_CNTL_AFDT:      // Anti-flicker detection threshold, 2 bits attr
        rtn = osd_atom_get_display_control(OSD_CNTL_AFDT);
        break;

    case OSD_DISP_CNTL_VPAFC:     // Video plane anti-flicker correction, 2 bits attr
        rtn = osd_atom_get_display_control(OSD_CNTL_VPAFC);
        break;

    case OSD_DISP_CNTL_ANIM:     // Animation mode, 0 no, 1 yes -- BJC 102102
        rtn = osd_atom_get_display_control(OSD_CNTL_ANIM);
        break;

    case OSD_DISP_CNTL_ANIMR:    // Animation rate, 3 bits attr -- BJC 102102
        rtn = osd_atom_get_display_control(OSD_CNTL_ANIMR);
        break;

    case OSD_DISP_CNTL_CHFSR:    // Custom horizontal FIR scaling ratio, 9 bits attr -- BJC 102102
        rtn = osd_atom_get_display_control(OSD_CNTL_CHFSR);
        break;

    default:
        rtn = 0;
        break;
    }
    
    os_release_mutex(gOSDMutex);
    /////////////////////////

    return rtn;
}



INT osd_osi_set_comp_gfx_surface_parm(GFX_SURFACE_T * pSurface, OSD_GRAPH_SURFACE_PARM_T parm, ULONG lValue1, ULONG lValue2)
{
    if(!gfx_osi_pSurface_valid(pSurface) || !IS_SURFACE_OSD_COMP(pSurface->uPlaneConfig)) 
    {
        PDEBUG("Invalid parameter or uninitialized surface!\n");
        return -1;    // we cann't do it
    }

    if(pSurface->uAttr & __GFX_SURFACE_OSDCURSOR)   // cursor
    {
        STB_OSD_CURSOR_CONTROL_BLOCK_T *pCntl;
        pCntl = os_get_logical_address(pSurface->hBuffer);
        switch(parm)
        {
        case OSD_GRAPH_SURFACE_FLICKER_CORRECTION:       // set the antiflicker filter value (v1)
            pCntl->anti_flicker = (unsigned)lValue1&0x03;   // two bits
            break;
            
        case OSD_GRAPH_SURFACE_SCREEN_OFFSET:            // the offset of surface to screen (v1 as horizontal, v2 as vertical)
            {