xxxfb.c

Framebuffer驱动示例程序.rar framebffer的编写示例程序说明

		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
	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 = 0;
	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;

	xxxfb_hw_set_var (dvar, fbi);

	return 0;
}

static int
__do_set_cmap (struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
{
	struct xxxfb_info *fbi = (struct xxxfb_info *) info;
	struct fb_cmap *dcmap = get_con_cmap (info, con);
	int err = 0;

	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, xxxfb_setcolreg, info);

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

	return err;
}

static int
xxxfb_set_cmap (struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
{
	struct display *disp = get_con_display (info, con);

	if (disp->visual == FB_VISUAL_TRUECOLOR ||
	    disp->visual == FB_VISUAL_STATIC_PSEUDOCOLOR)
		return -EINVAL;

	return __do_set_cmap (cmap, kspc, con, info);
}


static int
xxxfb_get_fix (struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
{
	struct display *display = get_con_display (info, con);

	*fix = info->fix;

	fix->line_length = display->line_length;
	fix->visual = display->visual;
	return 0;
}

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

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

static int
xxxfb_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
	     unsigned long arg, int con, struct fb_info *info)
{
}

static struct fb_ops xxxfb_ops = {
      owner:THIS_MODULE,
      fb_get_fix:xxxfb_get_fix,
      fb_get_var:xxxfb_get_var,
      fb_set_var:xxxfb_set_var,
      fb_get_cmap:xxxfb_get_cmap,
      fb_set_cmap:xxxfb_set_cmap,
      fb_ioctl:xxxfb_ioctl,
};

static int
xxxfb_switch (int con, struct fb_info *info)
{
	struct xxxfb_info *fbi = (struct xxxfb_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;

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

	return 0;
}

static int __init
xxxfb_map_video_memory (struct xxxfb_info *fbi)
{
	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 (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->map_size:%x, fbi->map_cpu:%x\n", fbi->map_size,
			fbi->map_cpu);
		printk ("fbi->map_dma:%x\n", fbi->map_dma);
	}

	return fbi->map_cpu ? 0 : -ENOMEM;
}

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

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

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

static struct xxxfb_info *__init
xxxfb_init_fbinfo (void)
{
	struct xxxfb_mach_info *inf;
	struct xxxfb_info *fbi;

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

	if (!fbi)
		return NULL;

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

	fbi->currcon = -1;

	strcpy (fbi->fb.fix.id, XXX_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, XXX_NAME);
	strcpy (fbi->fb.fontname, "Acorn8x8");

	fbi->fb.fbops = &xxxfb_ops;
	fbi->fb.changevar = NULL;
	fbi->fb.switch_con = xxxfb_switch;
	fbi->fb.updatevar = xxxfb_updatevar;
	fbi->fb.blank = xxxfb_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 = xxxfb_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;
	return fbi;
}

void
xxx_hw_init (void)
{
	/*init hareware */
	return;
}

int __init
xxxfb_init (void)
{
	struct xxxfb_info *fbi;
	int ret;

	fbi = xxxfb_init_fbinfo ();
	ret = -ENOMEM;
	if (!fbi)
		goto failed;

	ret = xxxfb_map_video_memory (fbi);
	if (ret)
		goto failed;

	xxx_hw_init ();
	xxxfb_set_var (&fbi->fb.var, -1, &fbi->fb);

	ret = register_framebuffer (&fbi->fb);
	if (ret < 0)
		goto failed;

	/* enable the LCD controller) */
	printk ("Installed XXX frame buffer\n");
	MOD_INC_USE_COUNT;
	return 0;

      failed:
	if (fbi)
		kfree (fbi);
	return ret;
}

int __init xxxfb_do_x_opt(int x_val)
{
	printk("xxxfb: xxxfb_do_x_opt, x is %d\n", x_val);
	
}

int __init
xxxfb_setup (char *options)
{
	char *this_opt;
	int i=0;
	if (!options || !*options)
		          return 0;
	for (this_opt = strtok(options, ","); this_opt;
		this_opt = strtok(NULL,      ",")) {
		i++;
		printk("xxxfb: option%d: %s\n", i, this_opt);
		if (!strncmp(this_opt, "x:", 2)) {
			xxxfb_do_x_opt(simple_strtoul(this_opt+2, NULL, 0));
		}

	}


	return 0;
}

#ifdef MODULE
module_init (xxxfb_init);
#endif