osd_inf_fb.c

IBM source for pallas/vulcan/vesta

    *green  = (UINT)pal.g<<8;
    *blue   = (UINT)pal.b<<8;
    *transp = (UINT)pal.a<<8;
    return 0;
}


// static 
int osd_inf_fb_setcolreg(unsigned regno, unsigned red, unsigned green,
              unsigned blue, unsigned transp,
              struct fb_info *fb_info)
{

    if(regno > 255)
    {
        PDEBUG("Failed to get surface palette entry %d!\n", regno);
        return -1;
    }

    switch (osd_gfx_bpp) {  // pixel size in bits
#ifdef FBCON_HAS_CFB8
    case 8:
        {
            GFX_PALETTE_T   pal;
            GFX_SURFACE_ACCESS_PALETTE_PARM_T parm;
            parm.hSurface = hFbSurface;
            parm.pPalette = &pal;
            parm.uCount = 1;
            parm.uStart = regno;
            
            pal.r = red>>8;
            pal.g = green>>8;
            pal.b = blue>>8;
            pal.a = 0xff;	// alpha
            if(gfx_inf_h_set_palette(&parm) < 0)
                return -1;
        }
        break;
#endif
#ifdef FBCON_HAS_CFB16
    case 16:
        /* 0:5:6:5 */
        fbcon_cmap.cfb16[regno] =
            ((red   & 0xf800)      ) |
            ((green & 0xfc00) >>  5) |
            ((blue  & 0xf800) >> 11);
        break;
#endif
#ifdef FBCON_HAS_CFB32
    case 32:
        red   >>= 8;
        green >>= 8;
        blue  >>= 8;
        fbcon_cmap.cfb32[regno] = 0xff000000       |  // alpha
            (red   << osd_fb_var_default.red.offset)   |
            (green << osd_fb_var_default.green.offset) |
            (blue  << osd_fb_var_default.blue.offset);
        break;
#endif
    default:
        return -1;
    }
    return 0;
}

/*
static void do_install_cmap(int con, struct fb_info *info)
{
    if (con != currcon)
        return;
    if (fb_display[con].cmap.len)
        fb_set_cmap(&fb_display[con].cmap, 1, vesa_setcolreg, info);
    else
        fb_set_cmap(fb_default_cmap(video_cmap_len), 1, vesa_setcolreg,
                info);
}
*/


static int osd_inf_fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
               struct fb_info *info)
{
    if (con == currcon) /* current console? */
        return fb_get_cmap(cmap, kspc, osd_inf_fb_getcolreg, info);
    else if (fb_display[con].cmap.len) /* non default colormap? */
        fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
    else
        fb_copy_cmap(fb_default_cmap(video_cmap_len),
             cmap, kspc ? 0 : 2);
    return 0;
}

static int osd_inf_fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
               struct fb_info *info)
{
    int err;

    if (!fb_display[con].cmap.len) {    /* no colormap allocated? */
        err = fb_alloc_cmap(&fb_display[con].cmap,video_cmap_len,0);
        if (err)
            return err;
    }
    if (con == currcon)            /* current console? */
        return fb_set_cmap(cmap, kspc, osd_inf_fb_setcolreg, info);
    else
        fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
    return 0;
}

static struct fb_ops osd_fb_ops = 
{
    owner:          THIS_MODULE,
    fb_get_fix:     osd_inf_fb_get_fix,
    fb_get_var:     osd_inf_fb_get_var,
    fb_set_var:     osd_inf_fb_set_var,
    fb_get_cmap:    osd_inf_fb_get_cmap,
    fb_set_cmap:    osd_inf_fb_set_cmap,
    fb_pan_display: osd_inf_fb_pan_display,
};


static void do_install_cmap(int con, struct fb_info *info)
{
    if (con != currcon)
        return;
    if (fb_display[con].cmap.len)
        fb_set_cmap(&fb_display[con].cmap, 1, osd_inf_fb_setcolreg, info);
    else
        fb_set_cmap(fb_default_cmap(video_cmap_len), 1, osd_inf_fb_setcolreg,info);
}

static int osd_inf_fb_switch(int con, struct fb_info *info)
{
    /* Do we have to save the colormap? */
    if (fb_display[currcon].cmap.len)
        fb_get_cmap(&fb_display[currcon].cmap, 1, osd_inf_fb_getcolreg, info);
    
    currcon = con;
    /* Install new colormap */
    if (con == currcon)
    {
        if (fb_display[con].cmap.len)
            fb_set_cmap(&fb_display[con].cmap, 1, osd_inf_fb_setcolreg, info);
        else
            fb_set_cmap(fb_default_cmap(video_cmap_len), 1, osd_inf_fb_setcolreg,info);
    }
    osd_inf_fb_update_var(con,info);
    return 1;
}

/* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */

static void osd_inf_fb_blank(int blank, struct fb_info *info)
{
    /* Not supported */
}


static int osd_inf_fb_init(void)
{
    int rtn;
    UINT uDispWidth, uDispHeight;
    GFX_CREATE_SURFACE_PARM_T surfc;
    GFX_SURFACE_DISPLAY_T disp;

    // print the driver verision info for futher reference
    PVERSION(FB_DRIVER_NAME);

    
    //if(scrman_osi_get_fmt(&uDispWidth, &uDispHeight) < 0)
    {
        uDispWidth = OSD_DEFAULT_XRES;
        uDispHeight = OSD_DEFAULT_YRES; 
    }
    
    PDEBUGE("Video screen size (%u, %u)\n", uDispWidth, uDispHeight);
    
    if(osd_scr_x < 0)   // default
        osd_scr_x = uDispWidth;
    
    if(osd_scr_y < 0)   // default 
        osd_scr_y = uDispHeight;
    
    if(osd_buf_x < 0)   // default
        osd_buf_x = OSD_DEFAULT_BUF_XRES;
    if(osd_buf_x < osd_scr_x)   // at least
        osd_buf_x = osd_scr_x;
    
    if(osd_buf_y < 0)   // default
        osd_buf_y = OSD_DEFAULT_BUF_YRES;
    if(osd_buf_y < osd_scr_y)   // at least
        osd_buf_y = osd_scr_y;
    
    if(osd_tv_left < 0)
        osd_tv_left = 0;
    
    if(osd_tv_upper < 0)
        osd_tv_upper = 0;
    
    if(osd_gfx_bpp < 8)
        osd_gfx_bpp = OSD_DEFAULT_BPP;
    
//    if(osd_gfx_alpha<0 ||osd_gfx_alpha>255) osd_gfx_alpha = 255;
    
    surfc.uWidth = osd_buf_x;
    surfc.uHeight = osd_buf_y;
    surfc.uFillColor = 0;
    surfc.graphDev = osd_fb_device;
    switch(osd_gfx_bpp)
    {
#ifdef FBCON_HAS_CFB8
    case 8:
        surfc.uPlaneConfig = GFX_SURFACE_CLUT8BPP_ARGB;
        rtn = gfx_inf_h_create_surface(&surfc);
        osd_fb_var_default.bits_per_pixel = 8;
        osd_fb_var_default.red.offset = 0;
        osd_fb_var_default.red.length = 8;
        osd_fb_var_default.red.msb_right = 0;
        osd_fb_var_default.green.offset = 0;
        osd_fb_var_default.green.length = 8;
        osd_fb_var_default.green.msb_right = 0;
        osd_fb_var_default.blue.offset = 0;
        osd_fb_var_default.blue.length = 8;
        osd_fb_var_default.blue.msb_right = 0;
        osd_fb_var_default.transp.offset = 0;
        osd_fb_var_default.transp.length = 8;
        osd_fb_var_default.transp.msb_right = 0;
        video_cmap_len = 256;
        break;
#endif
        
#ifdef FBCON_HAS_CFB16
#ifdef GFX_SURFACE_RGB_565
    case 16:   // RGB565
        surfc.uPlaneConfig = GFX_SURFACE_RGB_565;
        rtn = gfx_inf_h_create_surface(&surfc);
        osd_fb_var_default.bits_per_pixel = 16;
        osd_fb_var_default.red.offset = 11;
        osd_fb_var_default.red.length = 5;
        osd_fb_var_default.red.msb_right = 0;
        osd_fb_var_default.green.offset = 5;
        osd_fb_var_default.green.length = 6;
        osd_fb_var_default.green.msb_right = 0;
        osd_fb_var_default.blue.offset = 0;
        osd_fb_var_default.blue.length = 5;
        osd_fb_var_default.blue.msb_right = 0;
        osd_fb_var_default.transp.offset = 0;
        osd_fb_var_default.transp.length = 0;
        osd_fb_var_default.transp.msb_right = 0;
        video_cmap_len = 16;
        break;
#else
        PINFOE("16 bpp color depth is not supported by hardware\n");
        rtn = -EINVAL;
        break;
#endif
#endif
        
#ifdef FBCON_HAS_CFB32
#ifdef GFX_SURFACE_ARGB_8888    
    case 32:   // ARGB8888
        surfc.uPlaneConfig = GFX_SURFACE_ARGB_8888;
        rtn = gfx_inf_h_create_surface(&surfc);
        osd_fb_var_default.bits_per_pixel = 32;
        osd_fb_var_default.red.offset = 16;
        osd_fb_var_default.red.length = 8;
        osd_fb_var_default.red.msb_right = 0;
        osd_fb_var_default.green.offset = 8;
        osd_fb_var_default.green.length = 8;
        osd_fb_var_default.green.msb_right = 0;
        osd_fb_var_default.blue.offset = 0;
        osd_fb_var_default.blue.length = 8;
        osd_fb_var_default.blue.msb_right = 0;
        osd_fb_var_default.transp.offset = 24;
        osd_fb_var_default.transp.length = 8;
        osd_fb_var_default.transp.msb_right = 0;
        video_cmap_len = 16;
        break;
#else
        PINFOE("32 bpp color depth is not supported by hardware\n");
        rtn = -EINVAL;
        break;
#endif
#endif
        
    default:
        PFATAL("Unsupported graphics bpp config!\n");
        rtn = -EINVAL;
        break;
    }
    
    if( rtn < 0)
    {
        PFATAL("Error in creating graphics surface\n");
        rtn = -ENOMEM;
        return rtn;
    }
    
    hFbSurface = surfc.hSurface;

    fb_surface_info.hSurface = hFbSurface;
    fb_surface_physical.hSurface = hFbSurface;

    gfx_inf_h_lock_surface(&fb_surface_physical);  // to get it's physical address
    gfx_inf_h_unlock_surface(hFbSurface);
    rtn = _gfx_inf_h_get_surface_local(&fb_surface_info);
    if(rtn < 0)
    {
        gfx_inf_h_destroy_surface(hFbSurface);
        PFATAL("Error in creating graphics surface\n");
        rtn = -ENOMEM;
        return rtn;
    }
    
    osd_fb_var_default.xres = osd_scr_x;
    osd_fb_var_default.yres = osd_scr_y;
    osd_fb_var_default.xres_virtual = osd_buf_x;
    osd_fb_var_default.yres_virtual = osd_buf_y;
    osd_fb_var_default.xoffset = 0;
    osd_fb_var_default.yoffset = 0;
    osd_fb_var_default.grayscale = 0;
    osd_fb_var_default.nonstd = 0;
    osd_fb_var_default.activate = FB_ACTIVATE_NOW;
    osd_fb_var_default.accel_flags = 0;

    {
        GFX_SCREEN_INFO_T  scr;
        scr.uLeft =osd_tv_left;
        scr.uUpper = osd_tv_upper;
        scr.uWidth = osd_scr_x;
        scr.uHeight = osd_scr_y;
        gfx_inf_h_set_screen_info(&scr);
    }
    
    disp.hSurface = hFbSurface;
    gfx_inf_h_get_surface_display_parm(&disp);
    disp.uStartX = 0;
    disp.uStartY = 0;
    disp.uWinWidth = osd_scr_x;
    disp.uWinHeight = osd_scr_y;
    disp.uWinX = 0;
    disp.uWinY = 0;
    disp.bFlickerCorrect = osd_gfx_af;
    
    if(gfx_inf_h_set_surface_display_parm(&disp) < 0)
    {
        gfx_inf_h_destroy_surface(hFbSurface);
        PFATAL("Failed to config graphics surface parameters!\n");
        return -EPERM;
    }

    
    {
        GFX_SURFACE_VDEV_PARM_T vdev;
        vdev.hSurface = hFbSurface;
        vdev.graphDev = osd_fb_device;
        
        rtn = gfx_inf_h_attach_surface(&vdev);
    }
    if(rtn < 0)
    {
        gfx_inf_h_destroy_surface(hFbSurface);
        PFATAL("Failed to attach graphics surface to gfx device!\n");
        return -EPERM;
    }

    if(rtn < 0)
    {
        GFX_SURFACE_VDEV_PARM_T vdev;
        vdev.hSurface = hFbSurface;
        vdev.graphDev = osd_fb_device;
        
        rtn = gfx_inf_h_detach_surface(&vdev);
        gfx_inf_h_destroy_surface(hFbSurface);
        PFATAL("Failed to set graphics surface parm!\n");
        return -EIO;
    }

    {
        GFX_DISPLAY_CONTROL_PARM_T parm;
        // enable antiflicker on OSD display
        parm.parm = GFX_DISP_CNTL_EDAF;
        parm.uAttr = 1;
        gfx_inf_h_set_display_control(&parm);
        // set antiflicker detect threshold to afdt
        parm.parm = GFX_DISP_CNTL_AFDT;
        parm.uAttr = osd_gfx_afdt;
        gfx_inf_h_set_display_control(&parm);
    }
    
    if(osd_gfx_pat) // show the pattern for 5 seconds
    {
        printk(KERN_INFO "The video buffer is now filled with vertical bar pattern for 5 seconds!\n");
        osd_inf_debug_fill_fb(&fb_surface_info);
        {
            ULONG new_jif = jiffies + 500;
            while(new_jif > jiffies) ;
        }
        printk(KERN_INFO "Now you will not see the vertical bar if frame buffer is working!\n");
    }
    
    
    printk(KERN_INFO "%s: framebuffer  mapped to 0x%8.8x\n",
        osd_fb_dev_name, (UINT)fb_surface_info.plane[0].pPlane);
    
    /* some dummy values for timing to make fbset happy */
    osd_fb_var_default.pixclock     = 74074;
    osd_fb_var_default.left_margin  = osd_tv_left;
    osd_fb_var_default.right_margin = 0;
    osd_fb_var_default.upper_margin = osd_tv_upper;
    osd_fb_var_default.lower_margin = 0;
    osd_fb_var_default.hsync_len    = 108;
    osd_fb_var_default.vsync_len    = 25;
    
    strcpy(osd_fb_info.modename, osd_fb_dev_name);
    osd_fb_info.changevar = NULL;
    osd_fb_info.node = -1;
    osd_fb_info.fbops = &osd_fb_ops;
    osd_fb_info.disp=&osd_fb_disp;
    osd_fb_info.switch_con=&osd_inf_fb_switch;
    osd_fb_info.updatevar=&osd_inf_fb_update_var;
    osd_fb_info.blank=&osd_inf_fb_blank;
    osd_fb_info.flags=FBINFO_FLAG_DEFAULT;
    osd_inf_fb_set_disp(-1);
    
    
    if (register_framebuffer(&osd_fb_info)<0)
    {
        GFX_SURFACE_VDEV_PARM_T vdev;
        vdev.hSurface = hFbSurface;
        vdev.graphDev = osd_fb_device;
        
        rtn = gfx_inf_h_detach_surface(&vdev);
        gfx_inf_h_destroy_surface(hFbSurface);
        PFATAL("Failed to register frame buffer!\n");
        return -EINVAL;
    }
    printk(KERN_INFO "fb%d: %s frame buffer device\n",
        GET_FB_IDX(osd_fb_info.node), osd_fb_info.modename);

    if(osd_gfx_shared)
    {
        PINFOE("Shared surface handle is set to %d.\n", hFbSurface);
        gfx_inf_h_set_shared_surface(hFbSurface);
    }
    return 0;
}

static void osd_inf_fb_deinit(void)
{
    GFX_SURFACE_VDEV_PARM_T vdev;
    if (unregister_framebuffer(&osd_fb_info)<0)
    {
        PFATAL("Failed to unregister frame buffer!\n");
        return ;
    }

    vdev.hSurface = hFbSurface;
    vdev.graphDev = osd_fb_device;
    
    gfx_inf_h_detach_surface(&vdev);
    gfx_inf_h_destroy_surface(hFbSurface);

    return ;
}


/*
 *  Modularization
 */


module_init(osd_inf_fb_init);
module_exit(osd_inf_fb_deinit);