controlfb.c

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

	yres = control_reg_init[par->vmode-1]->vres;

	par->xres = xres;
	par->yres = yres;

	if (var->xres_virtual <= xres)
		par->vxres = xres;
	else if(var->xres_virtual > xres) {
		par->vxres = xres;
	} else	/* NotReached at present */
		par->vxres = (var->xres_virtual+7) & ~7;

	if (var->yres_virtual <= yres)
		par->vyres = yres;
	else
		par->vyres = var->yres_virtual;

	if (var->xoffset > 0 || var->yoffset+yres > par->vyres) {
		printk(KERN_ERR "Bad offsets in var_to_par\n");
		return -EINVAL;
	}

	par->xoffset = (var->xoffset+7) & ~7;
	par->yoffset = var->yoffset;


 	if (bpp <= 8)
		par->cmode = CMODE_8;
	else if (bpp <= 16)
		par->cmode = CMODE_16;
	else if (bpp <= 32)
		par->cmode = CMODE_32;
	else {
		printk(KERN_ERR "Bad bpp in var_to_par\n");
		return -EINVAL;
	}

	if (control_vram_reqd(par->vmode, par->cmode) > p->total_vram) {
		printk(KERN_ERR "Too much VRAM required for vmode %d cmode %d.\n", par->vmode, par->cmode);
		return -EINVAL;
	}

	/* Check if we know about the wanted video mode */
	if (control_reg_init[par->vmode - 1] == NULL) {
		printk(KERN_ERR "init is null in control_var_to_par().\n");
		/* I'm not sure if control has any specific requirements --	*/
		/* if we have a regvals struct, we're good to go?		*/
		return -EINVAL;
	}

	return 0;
}
#else
/* This routine takes a user-supplied var, and picks the best vmode/cmode from it. */
static int control_var_to_par(struct fb_var_screeninfo *var,
	struct fb_par_control *par, const struct fb_info *fb_info)
{
	struct fb_info_control *p = (struct fb_info_control *) fb_info;
	
	if(mac_var_to_vmode(var, &par->vmode, &par->cmode) != 0)
		return -EINVAL;
	par->xres = par->vxres = vmode_attrs[par->vmode - 1].hres;
	par->yres = par->vyres = vmode_attrs[par->vmode - 1].vres;
	par->xoffset = par->yoffset = 0;
	
	if (control_vram_reqd(par->vmode, par->cmode) > p->total_vram)
		return -EINVAL;

	/* Check if we know about the wanted video mode */
	if(!control_reg_init[par->vmode-1]) {
		/* I'm not sure if control has any specific requirements --	*/
		/* if we have a regvals struct, we're good to go?		*/
		return -EINVAL;
	}
	return 0;
}
#endif

/***********  Convert hardware data in par to an fb_var_screeninfo ***********/

static void control_par_to_var(struct fb_par_control *par, struct fb_var_screeninfo *var)
{
	struct control_regints *rv;
	
	rv = (struct control_regints *) control_reg_init[par->vmode - 1]->regs;
	
	memset(var, 0, sizeof(*var));
	var->xres = control_reg_init[par->vmode - 1]->hres;
	var->yres = control_reg_init[par->vmode - 1]->vres;
	var->xres_virtual = par->vxres;
	var->yres_virtual = par->vyres;
	var->xoffset = par->xoffset;
	var->yoffset = par->yoffset;
	var->grayscale = 0;
	
	if(par->cmode != CMODE_8 && par->cmode != CMODE_16 && par->cmode != CMODE_32) {
		printk(KERN_ERR "Bad color mode in control_par_to_var()!\n");
		par->cmode = CMODE_8;
	}
	switch(par->cmode) {
	case CMODE_8:
		var->bits_per_pixel = 8;
		var->red.offset = 0;
		var->red.length = 8;
		var->green.offset = 0;
		var->green.length = 8;
		var->blue.offset = 0;
		var->blue.length = 8;
		var->transp.offset = 0;
		var->transp.length = 0;
		break;
	case CMODE_16:	/* RGB 555 */
		var->bits_per_pixel = 16;
		var->red.offset = 10;
		var->red.length = 5;
		var->green.offset = 5;
		var->green.length = 5;
		var->blue.offset = 0;
		var->blue.length = 5;
		var->transp.offset = 0;
		var->transp.length = 0;
		break;
	case CMODE_32:	/* RGB 888 */
		var->bits_per_pixel = 32;
		var->red.offset = 16;
		var->red.length = 8;
		var->green.offset = 8;
		var->green.length = 8;
		var->blue.offset = 0;
		var->blue.length = 8;
		var->transp.offset = 24;
		var->transp.length = 8;
		break;
	}
	var->red.msb_right = 0;
	var->green.msb_right = 0;
	var->blue.msb_right = 0;
	var->transp.msb_right = 0;
	var->nonstd = 0;
	var->activate = 0;
	var->height = -1;
	var->width = -1;
	var->vmode = FB_VMODE_NONINTERLACED;

	var->left_margin = (rv->heblank - rv->hesync)
		<< ((par->vmode > 18) ? 2 : 1);
	var->right_margin = (rv->hssync - rv->hsblank)
		<< ((par->vmode > 18) ? 2 : 1);
	var->hsync_len = (rv->hperiod + 2 - rv->hssync + rv->hesync)
		<< ((par->vmode > 18) ? 2 : 1);

	var->upper_margin = (rv->veblank - rv->vesync) >> 1;
	var->lower_margin = (rv->vssync - rv->vsblank) >> 1;
	var->vsync_len = (rv->vperiod - rv->vssync + rv->vesync) >> 1;

	/* Acording to macmodes.c... */
	if((par->vmode >= 9 && par->vmode <= 12) ||
	   (par->vmode >= 16 && par->vmode <= 18) ||
	   (par->vmode == 20))
	{
		var->sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT;
	} else {
		var->sync = 0;          /* I suppose */
	}

    /* The reason these are both here: with my revised margin calculations, */
    /* these SHOULD both give the same answer for each mode.  Some day I    */
    /* will sit down and check the rest.  Works perfectly for vmode 13.     */

#if 0
/* jonh's pixclocks...*/
	/* no long long support in the kernel :-( */
	/* this splittig trick will work if xres > 232 */
	var->pixclock = 1000000000/
	(var->left_margin+var->xres+var->right_margin+var->hsync_len);
	var->pixclock *= 1000;
	var->pixclock /= vmode_attrs[par->vmode-1].vfreq*
	 (var->upper_margin+var->yres+var->lower_margin+var->vsync_len);
#else
/* danj's */
	/* 10^12 * clock_params[0] / (3906400 * clock_params[1] * 2^clock_params[2]) */
	/* (10^12 * clock_params[0] / (3906400 * clock_params[1])) >> clock_params[2] */
	/* (255990.17 * clock_params[0] / clock_params[1]) >> clock_params[2] */
	var->pixclock = 255990 * control_reg_init[par->vmode-1]->clock_params[0];
	var->pixclock /= control_reg_init[par->vmode-1]->clock_params[1];
	var->pixclock >>= control_reg_init[par->vmode-1]->clock_params[2];
#endif
}

static void control_par_to_fix(struct fb_par_control *par, struct fb_fix_screeninfo *fix,
	struct fb_info_control *p)
{
	memset(fix, 0, sizeof(*fix));
	strcpy(fix->id, "control");
	fix->mmio_start = p->control_regs_phys;
	fix->mmio_len = sizeof(struct control_regs);
	fix->type = FB_TYPE_PACKED_PIXELS;
	
	fix->ypanstep = 1;
	/*
		fix->type_aux = 0;
		fix->ywrapstep = 0;
		fix->ypanstep = 0;
		fix->xpanstep = 0;
	*/

	fix->smem_start = (p->frame_buffer_phys
		+ control_reg_init[par->vmode-1]->offset[par->cmode]);
	fix->smem_len = p->total_vram - control_reg_init[par->vmode-1]->offset[par->cmode];
	fix->visual = (par->cmode == CMODE_8) ?
		FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
	fix->line_length = par->vxres << par->cmode;
}

/* We never initialize any display except for p->disp.
   And p->disp is already memset to 0.  So no memset here.
   [Found by Takashi Oe]
*/
static void control_par_to_display(struct fb_par_control *par,
  struct display *disp, struct fb_fix_screeninfo *fix, struct fb_info_control *p)
{
	/* memset(disp, 0, sizeof(*disp)); */
	disp->type = fix->type;
	disp->can_soft_blank = 1;
	disp->scrollmode = SCROLL_YNOMOVE | SCROLL_YNOPARTIAL;
	disp->ypanstep = fix->ypanstep;
	disp->ywrapstep = fix->ywrapstep;
#if 0
		disp->type_aux = fix->type_aux;
		disp->cmap.red = NULL;	/* ??? danj */
		disp->cmap.green = NULL;
		disp->cmap.blue = NULL;
		disp->cmap.transp = NULL;
			/* Yeah, I realize I just set 0 = 0. */
#endif

	control_par_to_var(par, &disp->var);
	disp->screen_base = (char *) p->frame_buffer
		 + control_reg_init[par->vmode-1]->offset[par->cmode];
	disp->visual = fix->visual;
	disp->line_length = fix->line_length;
	control_set_dispsw(disp, par->cmode, p);
}

static void control_cfb16_revc(struct display *p, int xx, int yy)
{
    u8 *dest;
    int bytes = p->next_line, rows;

    dest = p->screen_base + yy * fontheight(p) * bytes + xx * fontwidth(p)*2;
    for (rows = fontheight(p); rows--; dest += bytes) {
       switch (fontwidth(p)) {
       case 16:
           ((u32 *)dest)[6] ^= 0x3def3def; ((u32 *)dest)[7] ^= 0x3def3def;
           /* FALL THROUGH */
       case 12:
           ((u32 *)dest)[4] ^= 0x3def3def; ((u32 *)dest)[5] ^= 0x3def3def;
           /* FALL THROUGH */
       case 8:
           ((u32 *)dest)[2] ^= 0x3def3def; ((u32 *)dest)[3] ^= 0x3def3def;
           /* FALL THROUGH */
       case 4:
           ((u32 *)dest)[0] ^= 0x3def3def; ((u32 *)dest)[1] ^= 0x3def3def;
       }
    }
}

static void control_cfb32_revc(struct display *p, int xx, int yy)
{
    u8 *dest;
    int bytes = p->next_line, rows;

    dest = p->screen_base + yy * fontheight(p) * bytes + xx * fontwidth(p) * 4;
    for (rows = fontheight(p); rows--; dest += bytes) {
       switch (fontwidth(p)) {
       case 16:
           ((u32 *)dest)[12] ^= 0x0f0f0f0f; ((u32 *)dest)[13] ^= 0x0f0f0f0f;
           ((u32 *)dest)[14] ^= 0x0f0f0f0f; ((u32 *)dest)[15] ^= 0x0f0f0f0f;
           /* FALL THROUGH */
       case 12:
           ((u32 *)dest)[8] ^= 0x0f0f0f0f; ((u32 *)dest)[9] ^= 0x0f0f0f0f;
           ((u32 *)dest)[10] ^= 0x0f0f0f0f; ((u32 *)dest)[11] ^= 0x0f0f0f0f;
           /* FALL THROUGH */
       case 8:
           ((u32 *)dest)[4] ^= 0x0f0f0f0f; ((u32 *)dest)[5] ^= 0x0f0f0f0f;
           ((u32 *)dest)[6] ^= 0x0f0f0f0f; ((u32 *)dest)[7] ^= 0x0f0f0f0f;
           /* FALL THROUGH */
       case 4:
           ((u32 *)dest)[0] ^= 0x0f0f0f0f; ((u32 *)dest)[1] ^= 0x0f0f0f0f;
           ((u32 *)dest)[2] ^= 0x0f0f0f0f; ((u32 *)dest)[3] ^= 0x0f0f0f0f;
           /* FALL THROUGH */
       }
    }
}

static struct display_switch control_cfb16 = {
    setup:		fbcon_cfb16_setup,
    bmove:		fbcon_cfb16_bmove,
    clear:		fbcon_cfb16_clear,
    putc:		fbcon_cfb16_putc,
    putcs:		fbcon_cfb16_putcs,
    revc:		control_cfb16_revc,
    clear_margins:	fbcon_cfb16_clear_margins,
    fontwidthmask:	FONTWIDTH(4)|FONTWIDTH(8)|FONTWIDTH(12)|FONTWIDTH(16)
};

static struct display_switch control_cfb32 = {
    setup:		fbcon_cfb32_setup,
    bmove:		fbcon_cfb32_bmove,
    clear:		fbcon_cfb32_clear,
    putc:		fbcon_cfb32_putc,
    putcs:		fbcon_cfb32_putcs,
    revc:		control_cfb32_revc,
    clear_margins:	fbcon_cfb32_clear_margins,
    fontwidthmask:	FONTWIDTH(4)|FONTWIDTH(8)|FONTWIDTH(12)|FONTWIDTH(16)
};


static void control_set_dispsw(struct display *disp, int cmode, struct fb_info_control *p)
{
	switch (cmode) {
#ifdef FBCON_HAS_CFB8
		case CMODE_8:
			disp->dispsw = &fbcon_cfb8;
			break;
#endif
#ifdef FBCON_HAS_CFB16
		case CMODE_16:
			disp->dispsw = &control_cfb16;
			disp->dispsw_data = p->fbcon_cmap.cfb16;
			break;
#endif
#ifdef FBCON_HAS_CFB32
		case CMODE_32:
			disp->dispsw = &control_cfb32;
			disp->dispsw_data = p->fbcon_cmap.cfb32;
			break;
#endif
		default:
			disp->dispsw = &fbcon_dummy;
			break;
	}
}

static void __init control_init_info(struct fb_info *info, struct fb_info_control *p)
{
	strcpy(info->modename, "control");
	info->node = -1;	/* ??? danj */
	info->fbops = &controlfb_ops;
	info->disp = &p->display;
	strcpy(info->fontname, fontname);
	info->changevar = NULL;
	info->switch_con = &controlfb_switch;
	info->updatevar = &controlfb_updatevar;
	info->blank = &controlfb_blank;
}

/* Parse user speficied options (`video=controlfb:') */
void __init control_setup(char *options)
{
	char *this_opt;

	if (!options || !*options)
		return;

	for (this_opt = strtok(options, ","); this_opt;
	     this_opt = strtok(NULL, ",")) {
		if (!strncmp(this_opt, "font:", 5)) {
			char *p;
			int i;

			p = this_opt +5;
			for (i = 0; i < sizeof(fontname) - 1; i++)
				if (!*p || *p == ' ' || *p == ',')
					break;
			memcpy(fontname, this_opt + 5, i);
			fontname[i] = 0;
		}
		if (!strncmp(this_opt, "vmode:", 6)) {
			int vmode = simple_strtoul(this_opt+6, NULL, 0);
		if (vmode > 0 && vmode <= VMODE_MAX)
			default_vmode = vmode;
		} else if (!strncmp(this_opt, "cmode:", 6)) {
			int depth = simple_strtoul(this_opt+6, NULL, 0);
			switch (depth) {
			 case CMODE_8:
			 case CMODE_16:
			 case CMODE_32:
			 	default_cmode = depth;
			 	break;
			 case 8:
				default_cmode = CMODE_8;
				break;
			 case 15:
			 case 16:
				default_cmode = CMODE_16;
				break;
			 case 24:
			 case 32:
				default_cmode = CMODE_32;
				break;
			}
		}
	}
}

#if 0
static int controlfb_pan_display(struct fb_var_screeninfo *var,
			   struct controlfb_par *par,
			   const struct fb_info *fb_info)
{
    /*
     *  Pan (or wrap, depending on the `vmode' field) the display using the
     *  `xoffset' and `yoffset' fields of the `var' structure.
     *  If the values don't fit, return -EINVAL.
     */

	FUNCID;

    return 0;
}

#endif