w90p710fb.c

winbond w90p710 lcd frame buffer driver。

    //fbi->palette_size = var->bits_per_pixel == 8 ? 256 : 16;
    fbi->palette_size =  256;

    palette_mem_size = fbi->palette_size * sizeof(u16);

    fbi->palette_cpu = (u16 *)(fbi->map_cpu + PAGE_SIZE - palette_mem_size);
    fbi->palette_dma = fbi->map_dma + PAGE_SIZE - palette_mem_size;

    fb_set_cmap(&fbi->fb.cmap, 1, w90p710fb_setcolreg, &fbi->fb);

    w90p710fb_set_truecolor(var->bits_per_pixel >= 16);

    w90p710fb_activate_var(var, fbi);

    //fbi->palette_cpu[0] = (fbi->palette_cpu[0] &
	//			0xcfff) | palette_pbs(var);
	
	LEAVE();
}



static int
w90p710fb_set_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
{
    struct w90p710fb_info *fbi = (struct w90p710fb_info *)info;
    struct fb_var_screeninfo *dvar = get_con_var(&fbi->fb, con);
    struct display *display = get_con_display(&fbi->fb, con);
    int err, chgvar = 0, rgbidx;

	ENTER();
	
    err = w90p710fb_validate_var(var, fbi);

    if (err) 
	return err;

    if (var->activate & FB_ACTIVATE_TEST)
	return 0;
    if ((var->activate & FB_ACTIVATE_MASK) != FB_ACTIVATE_NOW)
	return -EINVAL;

    if (dvar->xres != var->xres)
	chgvar = 1;
    if (dvar->yres != var->yres)
	chgvar = 1;
    if (dvar->xres_virtual != var->xres_virtual)
	chgvar = 1;
    if (dvar->yres_virtual != var->yres_virtual)
	chgvar = 1;
    if (dvar->bits_per_pixel != var->bits_per_pixel)
	chgvar = 1;
    if (con < 0)
	chgvar = 0;

    switch (var->bits_per_pixel) {
#ifdef FBCON_HAS_MFB
    case 1:
	    	if (fbi->cmap_static)
		    display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
		else
		    display->visual = FB_VISUAL_PSEUDOCOLOR;
		display->line_length 	= var->xres / 8;
		display->dispsw		= &fbcon_mfb;
		rgbidx			= RGB_8;
		break;
#endif
#ifdef FBCON_HAS_CFB2
    case 2:
	    	if (fbi->cmap_static)
		    display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
		else
		    display->visual = FB_VISUAL_PSEUDOCOLOR;
		display->line_length 	= var->xres / 4;
		display->dispsw		= &fbcon_cfb2;
		rgbidx			= RGB_8;
		break;
#endif
#ifdef FBCON_HAS_CFB4
	case 4:
	    if (fbi->cmap_static)
		    display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;		    
		else
		    display->visual = FB_VISUAL_PSEUDOCOLOR;
				
		display->line_length 	= var->xres / 2;
		display->dispsw		= &fbcon_cfb4;
		rgbidx			= RGB_8;
		break;
#endif
#ifdef	FBCON_HAS_CFB8
	case 8:
		if (fbi->cmap_static)
		    display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
		else
		    display->visual = FB_VISUAL_PSEUDOCOLOR;
		display->line_length 	= var->xres;
	    display->dispsw	= &fbcon_cfb8;
		rgbidx = RGB_8;
		break;
#endif
#ifdef FBCON_HAS_CFB16
	case 16:
		display->visual		= FB_VISUAL_TRUECOLOR;
		display->line_length	= var->xres * 2;
		display->dispsw		= &fbcon_cfb16;
		display->dispsw_data	= fbi->fb.pseudo_palette;
		rgbidx			= RGB_16;
		break;
#endif
#ifdef FBCON_HAS_CFB24
	case 24:
		display->visual		= FB_VISUAL_TRUECOLOR;
		display->line_length	= var->xres * 4;
		display->dispsw		= &fbcon_cfb24;
		display->dispsw_data	= fbi->fb.pseudo_palette;
		rgbidx			= RGB_24;
		break;
#endif
	default:
		rgbidx = 0;
		display->dispsw = &fbcon_dummy;
		break;
    }

    display->screen_base 	= fbi->screen_cpu;
    display->next_line		= display->line_length;
    display->type			= fbi->fb.fix.type;
    display->type_aux		= fbi->fb.fix.type_aux;
    display->ypanstep		= fbi->fb.fix.ypanstep;
    display->ywrapstep		= fbi->fb.fix.ywrapstep;
    display->can_soft_blank	= 1;
    display->inverse		= fbi->cmap_inverse;

    *dvar			= *var;
    dvar->activate		&= ~FB_ACTIVATE_ALL;

    dvar->red			= fbi->rgb[rgbidx]->red;
    dvar->green			= fbi->rgb[rgbidx]->green;
    dvar->blue			= fbi->rgb[rgbidx]->blue;
    dvar->transp		= fbi->rgb[rgbidx]->transp;

    display->var = *dvar;

    if (var->activate & FB_ACTIVATE_ALL)
	fbi->fb.disp->var = *dvar;

    if (chgvar && info && fbi->fb.changevar)
	fbi->fb.changevar(con);

    if (con != fbi->currcon)
	return 0;
	
	w90p710fb_hw_set_var(dvar, fbi);

    LEAVE();
    
    return 0;
}

static int
__do_set_cmap(struct fb_cmap *cmap, int kspc, int con,
	      struct fb_info *info)
{
    struct w90p710fb_info *fbi = (struct w90p710fb_info *)info;
    struct fb_cmap *dcmap = get_con_cmap(info, con);
    int err = 0;
	
	ENTER();
		
	if (con == -1)
	con = fbi->currcon;

    if (con >= 0)
	err = fb_alloc_cmap(&fb_display[con].cmap, fbi->palette_size, 0);

    if (!err && con == fbi->currcon)
	err = fb_set_cmap(cmap, kspc, w90p710fb_setcolreg, info);

    if (!err)
	fb_copy_cmap(cmap, dcmap, kspc ? 0 : 1);
	
	LEAVE();
	
    return err;
}
 

static int
w90p710fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
		   struct fb_info *info)
{
    struct display *disp = get_con_display(info, con);
    
	ENTER();
	
    if (disp->visual == FB_VISUAL_TRUECOLOR ||
        disp->visual == FB_VISUAL_STATIC_PSEUDOCOLOR)
	return -EINVAL;
		
    LEAVE();
    
    return __do_set_cmap(cmap, kspc, con, info);
}


static int
w90p710fb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
{
    struct display *display = get_con_display(info, con);
	
	ENTER();
	
    *fix = info->fix;

    fix->line_length = display->line_length;
    fix->visual      = display->visual;
    
    LEAVE();
    
    return 0;
}

static int
w90p710fb_get_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
{
	ENTER();
	
    *var = *get_con_var(info, con);
    
    LEAVE();
    return 0;
}

static int
w90p710fb_get_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
{
    struct fb_cmap *dcmap = get_con_cmap(info, con);
	
	ENTER();
	
    fb_copy_cmap(dcmap, cmap, kspc ? 0 : 2);
    
    LEAVE();
    return 0;
}

static struct fb_ops w90p710fb_ops = {
	owner:			THIS_MODULE,
	fb_get_fix:		w90p710fb_get_fix,
	fb_get_var:		w90p710fb_get_var,
	fb_set_var:		w90p710fb_set_var,
	fb_get_cmap:	w90p710fb_get_cmap,
	fb_set_cmap:	w90p710fb_set_cmap,
	//fb_ioctl:		w90p710fb_ioctl,
};

static int w90p710fb_switch(int con, struct fb_info *info)
{
    struct w90p710fb_info *fbi = (struct w90p710fb_info *)info;
    struct display *disp;
    struct fb_cmap *cmap;

    if (con == fbi->currcon)
	return 0;

    if (fbi->currcon >= 0) {
	disp = fb_display + fbi->currcon;

	disp->var = fbi->fb.var;

	if (disp->cmap.len)
	    fb_copy_cmap(&fbi->fb.cmap, &disp->cmap, 0);

    }

    fbi->currcon = con;
    disp = fb_display + con;

    fb_alloc_cmap(&fbi->fb.cmap, 256, 0);

    if (disp->cmap.len)
	cmap = &disp->cmap;
    else
	cmap = fb_default_cmap(1 << disp->var.bits_per_pixel);

    fb_copy_cmap(cmap, &fbi->fb.cmap, 0);

    fbi->fb.var = disp->var;
    fbi->fb.var.activate = FB_ACTIVATE_NOW;

    w90p710fb_set_var(&fbi->fb.var, con, info);

    return 0;
}

#if 0
/*
 * Power management hook. Note that we won't be called from IRQ context,
 * unlike the blank functions above, so we may sleep
 */
static int w90p710_pm_callback(struct pm_dev *pm_dev, pm_request_t req, void *data)
{
	//struct w90p710fb_info *fbi = pm_dev->data;
	//u_long flags;

	//printk("pm_callback: %d\n", req);


	return 0;
}
#endif

static int __init w90p710fb_map_video_memory(struct w90p710fb_info *fbi)
{

	ENTER();
	
//    printk("fbi->map_dma = %x\n",fbi->map_dma);
    
    
    fbi->map_size = PAGE_ALIGN(fbi->fb.fix.smem_len + PAGE_SIZE);
    fbi->map_cpu = consistent_alloc(GFP_KERNEL, fbi->map_size,
	    			    &fbi->map_dma);
#if 0	
	printk("fbi->map_dma = %x\n",fbi->map_dma);
	printk("fbi->map_cpu = %x\n",fbi->map_cpu);
	printk("fbi->map_size = %x\n",fbi->map_size);
#endif	
    if (fbi->map_cpu) {
		fbi->screen_cpu = fbi->map_cpu + PAGE_SIZE;
		fbi->screen_dma = fbi->map_dma + PAGE_SIZE;
		fbi->fb.fix.smem_start = fbi->screen_dma;
		//printk("fbi->fb.fix.smem_start = 0x%lx\n",fbi->fb.fix.smem_start);
    }
	//printk("fbi->fb.fix.smem_start 1= 0x%lx\n",fbi->fb.fix.smem_start);
	
	LEAVE();
	
    return fbi->map_cpu ? 0 : -ENOMEM;
}

static int w90p710fb_updatevar(int con, struct fb_info *info)
{
    return 0;
}

static void w90p710fb_blank(int blank, struct fb_info *info)
{
}

static struct fb_monspecs monspecs __initdata = {
    30000, 70000, 50, 65, 0
};

static struct w90p710fb_info * __init w90p710fb_init_fbinfo(void)
{
    struct w90p710fb_mach_info *inf;
    struct w90p710fb_info *fbi;

	ENTER();
	
    fbi = kmalloc(sizeof(struct w90p710fb_info) + sizeof(struct display) +
	    	  sizeof(u16)*16, GFP_KERNEL);

    if (!fbi)
	return NULL;

    memset(fbi, 0, sizeof(struct w90p710fb_info) + sizeof(struct display));

    fbi->currcon		= -1;

    strcpy(fbi->fb.fix.id, W90P710_NAME);

    fbi->fb.fix.type		= FB_TYPE_PACKED_PIXELS;
    fbi->fb.fix.type_aux		= 0;
    fbi->fb.fix.xpanstep		= 0;
    fbi->fb.fix.ypanstep		= 0;
    fbi->fb.fix.ywrapstep	= 0;
    fbi->fb.fix.accel		= FB_ACCEL_NONE;

    fbi->fb.var.nonstd		= 0;
    fbi->fb.var.activate		= FB_ACTIVATE_NOW;
    fbi->fb.var.height		= -1;
    fbi->fb.var.width		= -1;
    fbi->fb.var.accel_flags	= 0;
    fbi->fb.var.vmode		= FB_VMODE_NONINTERLACED;

    strcpy(fbi->fb.modename, W90P710_NAME);
    strcpy(fbi->fb.fontname, "Acorn8x8");

    fbi->fb.fbops			= &w90p710fb_ops;
    fbi->fb.changevar		= NULL;
    fbi->fb.switch_con		= w90p710fb_switch;
    fbi->fb.updatevar		= w90p710fb_updatevar;
    fbi->fb.blank			= w90p710fb_blank;
    fbi->fb.flags			= FBINFO_FLAG_DEFAULT;
    fbi->fb.node			= -1;
    fbi->fb.monspecs		= monspecs;
    fbi->fb.disp			= (struct display *)(fbi + 1);
    fbi->fb.pseudo_palette	= (void *)(fbi->fb.disp + 1);

    fbi->rgb[RGB_8]			= &rgb_8;
    fbi->rgb[RGB_16]		= &def_rgb_16;

    inf	= w90p710fb_get_machine_info(fbi);


    fbi->max_xres			= inf->xres;

    fbi->fb.var.xres		= inf->xres;
    fbi->fb.var.xres_virtual	= inf->xres;
    fbi->max_yres			= inf->yres;
    fbi->fb.var.yres		= inf->yres;
    fbi->fb.var.yres_virtual	= inf->yres;
    fbi->max_bpp			= inf->bpp;
    fbi->fb.var.bits_per_pixel  = inf->bpp;
    fbi->fb.var.pixclock		= inf->pixclock;
    fbi->fb.var.hsync_len	= inf->hsync_len;
    fbi->fb.var.left_margin	= inf->left_margin;
    fbi->fb.var.right_margin	= inf->right_margin;
    fbi->fb.var.vsync_len	= inf->vsync_len;
    fbi->fb.var.upper_margin	= inf->upper_margin;
    fbi->fb.var.lower_margin	= inf->lower_margin;
    fbi->fb.var.sync		= inf->sync;
    fbi->fb.var.grayscale	= inf->cmap_grayscale;
    fbi->cmap_inverse		= inf->cmap_inverse;
    fbi->cmap_static		= inf->cmap_static;
    //fbi->fb.fix.smem_len		= fbi->max_xres * fbi->max_yres *
	//			  			fbi->max_bpp / 8;
	fbi->fb.fix.smem_len		= FB_Size ;
	
	LEAVE();
	
    return fbi;
}

void w90p710_lcd_init(struct w90p710fb_info *fbi)
{
	int bursty = 1;
	
	ENTER();    
    
	/* Configure LCD GPIO */
	writel(0x00555555,REG_GPIO_CFG6);  //GPIO  30-41
                           	
#ifdef CONFIG_W90P710_LCD_TFT
                      		
#ifdef CONFIG_W90P710_LCD_TFT_CASIO    						
    /* Init CASIO panel */
    InitCasioLCD();    
    
    /* Configure LCD Controller Control Register */
    outpw(REG_LCD_LCDCON, 	LCD_LCDCON_LCDBUS_24 | 
    						LCD_LCDCON_LCDTFTTYPE |		//for casio panel
    						LCD_LCDCON_LCDTFT |
    						LCD_LCDCON_CASIOSHOWTYPE_R1G2B3R4G5B6); 		//for TFT panel	
#else
#ifdef CONFIG_W90P710_LCD_TFT_AUO960240
	/* Configure LCD Controller Control Register */
	outpw(REG_LCD_LCDCON, inpw(REG_LCD_LCDCON) | LCD_LCDCON_LCDTFT |
												 LCD_LCDCON_LCDBUS_24 |
												 LCD_LCDCON_CASIOSHOWTYPE_R1G1B1R2G2B2 |
												 LCD_LCDCON_LCDTFTTYPE);		
	/* Change RGB sequence to RBG for down-side up displaying at AUO */
	outpw(REG_LCD_LCDCON, (inpw(REG_LCD_LCDCON) & 0xFFFFF3FF) | LCD_LCDCON_RGBSEQ_RBG);
#else

#ifdef CONFIG_W90P710_LCD_TFT_TOPPOLY240320   	
   	outpw(REG_GPIO_CFG2, 0x000FFFFF);
    outpw(REG_GPIO_CFG5, 0x15540005);
#endif

	/* Configure LCD GPIO for 18bits */
   	//writel(0x000FFFFF,REG_GPIO_CFG1);	//GPIO  20-29,share with SD
   	writel(0x000FFFFF,REG_GPIO_CFG2);	//GPIO  20-29,share with MAC
    	
	/* Configure LCD Controller Control Register */
    outpw(REG_LCD_LCDCON, 	LCD_LCDCON_LCDBUS_18 |     
                      		LCD_LCDCON_LCDTFT ); 		//for TFT panel                      		
#endif
#endif

#ifdef CONFIG_W90P710_LCD_TFT_24BPP