From mboxrd@z Thu Jan  1 00:00:00 1970
Message-ID: <19990709095001.M822@radicalmedia.com>
Date: Fri, 9 Jul 1999 09:50:01 -0400
From: Mark Abene <phiber@radicalmedia.com>
To: Tom Rini <trini@disparity.net>
Cc: linuxppc-dev@lists.linuxppc.org
Subject: Re: platinum video makes me cry...
References: <Pine.LNX.3.96L.990708142815.2134H-100000@unix47.andrew.cmu.edu> <Pine.BSF.3.96.990709093050.70746F-100000@silver.teardrop.net>
Mime-Version: 1.0
Content-Type: multipart/mixed; boundary=L2Brqb15TUChFOBK
In-Reply-To: <Pine.BSF.3.96.990709093050.70746F-100000@silver.teardrop.net>; from Tom Rini on Fri, Jul 09, 1999 at 09:32:52AM -0400
Sender: owner-linuxppc-dev@lists.linuxppc.org
List-Id: <linuxppc-dev@lists.linuxppc.org>


--L2Brqb15TUChFOBK
Content-Type: text/plain; charset=us-ascii

I'll attach the "current" platinumfb.c file in its entirety.  Although I've
just been informed (and I've verified) that 32bpp doesn't work.  I didn't
originally notice because I normally use vmode 20 16, and hadn't checked
32bpp.  So the changes only fix 16bpp (8 still works as before).
I'm looking into why 32bpp doesn't work.  I'm still irritated at how much
abstraction was done to make the driver "FBDev-aware".  It was so much simpler
in 2.1.24, when ALL recognized modes worked in ALL available bit-depths.
Now I'm playing catch-up since I was previously much too busy to know what
was going on with newer kernels and FBDev.

Ugh.
-Mark


--L2Brqb15TUChFOBK
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment; filename="platinumfb.c"

/*
 *  platinumfb.c -- frame buffer device for the PowerMac 'platinum' display
 *
 *  Copyright (C) 1998 Franz Sirl
 *
 *  Frame buffer structure from:
 *    drivers/video/controlfb.c -- frame buffer device for
 *    Apple 'control' display chip.
 *    Copyright (C) 1998 Dan Jacobowitz
 *
 *  Hardware information from:
 *    platinum.c: Console support for PowerMac "platinum" display adaptor.
 *    Copyright (C) 1996 Paul Mackerras and Mark Abene
 *
 *  This file is subject to the terms and conditions of the GNU General Public
 *  License. See the file COPYING in the main directory of this archive for
 *  more details.
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/tty.h>
#include <linux/malloc.h>
#include <linux/vmalloc.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/fb.h>
#include <linux/selection.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/nvram.h>
#ifdef CONFIG_FB_COMPAT_XPMAC
#include <asm/vc_ioctl.h>
#endif
#include <asm/io.h>
#include <asm/prom.h>
#include <asm/pgtable.h>
#include <asm/adb.h>

#include <video/fbcon.h>
#include <video/fbcon-cfb8.h>
#include <video/fbcon-cfb16.h>
#include <video/fbcon-cfb32.h>
#include <video/macmodes.h>

#include "platinumfb.h"

static char fontname[40] __initdata = { 0 };

static int currcon = 0;

static int default_vmode = VMODE_NVRAM;
static int default_cmode = CMODE_NVRAM;

struct fb_par_platinum {
	int	vmode, cmode;
	int	xres, yres;
	int	vxres, vyres;
	int	xoffset, yoffset;
};

struct fb_info_platinum {
	struct fb_info			fb_info;
	struct display			disp;
	struct fb_par_platinum		default_par;
	struct fb_par_platinum		current_par;

	struct {
		__u8 red, green, blue;
	}				palette[256];
	
	volatile struct cmap_regs	*cmap_regs;
	unsigned long			cmap_regs_phys;
	
	volatile struct platinum_regs	*platinum_regs;
	unsigned long			platinum_regs_phys;
	
	__u8				*frame_buffer;
	volatile __u8			*base_frame_buffer;
	unsigned long			frame_buffer_phys;
	
	unsigned long			total_vram;
	int				clktype;
	int				dactype;

	union {
#ifdef FBCON_HAS_CFB16
		u16 cfb16[16];
#endif
#ifdef FBCON_HAS_CFB32
		u32 cfb32[16];
#endif
	} fbcon_cmap;
};

/*
 * Frame buffer device API
 */

static int platinum_open(struct fb_info *info, int user);
static int platinum_release(struct fb_info *info, int user);
static int platinum_get_fix(struct fb_fix_screeninfo *fix, int con,
			    struct fb_info *fb);
static int platinum_get_var(struct fb_var_screeninfo *var, int con,
			    struct fb_info *fb);
static int platinum_set_var(struct fb_var_screeninfo *var, int con,
			    struct fb_info *fb);
static int platinum_pan_display(struct fb_var_screeninfo *var, int con,
				struct fb_info *fb);
static int platinum_get_cmap(struct fb_cmap *cmap, int kspc, int con,
			     struct fb_info *info);
static int platinum_set_cmap(struct fb_cmap *cmap, int kspc, int con,
			     struct fb_info *info);
static int platinum_ioctl(struct inode *inode, struct file *file, u_int cmd,
			  u_long arg, int con, struct fb_info *info);


/*
 * Interface to the low level console driver
 */

static int platinum_switch(int con, struct fb_info *fb);
static int platinum_updatevar(int con, struct fb_info *fb);
static void platinum_blank(int blank, struct fb_info *fb);


/*
 * internal functions
 */

static inline int platinum_vram_reqd(int video_mode, int color_mode);
static int read_platinum_sense(struct fb_info_platinum *info);
static void set_platinum_clock(struct fb_info_platinum *info);
static void platinum_set_par(const struct fb_par_platinum *par, struct fb_info_platinum *info);
static int platinum_par_to_var(struct fb_var_screeninfo *var,
			       const struct fb_par_platinum *par,
			       const struct fb_info_platinum *info);
static int platinum_var_to_par(const struct fb_var_screeninfo *var,
			       struct fb_par_platinum *par,
			       const struct fb_info_platinum *info);
static int platinum_encode_fix(struct fb_fix_screeninfo *fix,
			       const struct fb_par_platinum *par,
			       const struct fb_info_platinum *info);
static int platinum_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
			      u_int *transp, struct fb_info *fb);
static int platinum_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
			      u_int transp, struct fb_info *fb);
static void do_install_cmap(int con, struct fb_info *info);


/*
 * Interface used by the world
 */

void platinum_init(void);
#ifdef CONFIG_FB_OF
void platinum_of_init(struct device_node *dp);
#endif
void platinum_setup(char *options, int *ints);


static struct fb_ops platinumfb_ops = {
	platinum_open,
	platinum_release,
	platinum_get_fix,
	platinum_get_var,
	platinum_set_var,
	platinum_get_cmap,
	platinum_set_cmap,
	platinum_pan_display,
	platinum_ioctl
};


__openfirmware


static int platinum_open(struct fb_info *info, int user)
{
	MOD_INC_USE_COUNT;
	return 0;
}

static int platinum_release(struct fb_info *info, int user)
{
	MOD_DEC_USE_COUNT;
	return 0;
}

static int platinum_get_fix(struct fb_fix_screeninfo *fix, int con,
			    struct fb_info *fb)
{
	const struct fb_info_platinum *info = (struct fb_info_platinum *)fb;
	struct fb_par_platinum par;

	if (con == -1)
		par = info->default_par;
	else
		platinum_var_to_par(&fb_display[con].var, &par, info);

	platinum_encode_fix(fix, &par, info);
	return 0;
}

static int platinum_get_var(struct fb_var_screeninfo *var, int con,
			    struct fb_info *fb)
{
	const struct fb_info_platinum *info = (struct fb_info_platinum *)fb;

	if (con == -1)
		platinum_par_to_var(var, &info->default_par, info);
	else
		*var = fb_display[con].var;

	return 0;
}

static int platinum_set_var(struct fb_var_screeninfo *var, int con,
			    struct fb_info *fb)
{
	struct fb_info_platinum *info = (struct fb_info_platinum *) fb;
	struct fb_par_platinum par;
	struct display *display;
	int oldxres, oldyres, oldvxres, oldvyres, oldbpp, err;
	int activate = var->activate;
        struct platinum_regvals *init;


	display = (con >= 0) ? &fb_display[con] : fb->disp;

	if((err = platinum_var_to_par(var, &par, info))) {
		printk(KERN_ERR "platinum_set_var: error calling platinum_var_to_par: %d.\n", err);
		return err;
	}
	
	platinum_par_to_var(var, &par, info);

	if ((activate & FB_ACTIVATE_MASK) != FB_ACTIVATE_NOW) {
		printk(KERN_INFO "platinum_set_var: Not activating.\n");
		return 0;
	}

        init = platinum_reg_init[par.vmode-1];

	oldxres = display->var.xres;
	oldyres = display->var.yres;
	oldvxres = display->var.xres_virtual;
	oldvyres = display->var.yres_virtual;
	oldbpp = display->var.bits_per_pixel;
	display->var = *var;

	if (oldxres != var->xres || oldyres != var->yres ||
	    oldvxres != var->xres_virtual || oldyres != var->yres_virtual ||
	    oldbpp != var->bits_per_pixel) {
	    struct fb_fix_screeninfo fix;

	    platinum_encode_fix(&fix, &par, info);
	    /*display->screen_base = (char *) info->frame_buffer + 0x1000;*/
	    /*display->screen_base = (char *) fix.smem_start;*/
	    display->screen_base = (char *) info->frame_buffer + init->fb_offset + 0x20;
	    display->visual = fix.visual;
	    display->type = fix.type;
	    display->type_aux = fix.type_aux;
	    display->ypanstep = fix.ypanstep;
	    display->ywrapstep = fix.ywrapstep;
	    display->line_length = fix.line_length;
	    display->can_soft_blank = 1;
	    display->inverse = 0;

	    switch(par.cmode) {
#ifdef FBCON_HAS_CFB8
	     case CMODE_8:
		display->dispsw = &fbcon_cfb8;
		break;
#endif
#ifdef FBCON_HAS_CFB16
	     case CMODE_16:
		display->dispsw = &fbcon_cfb16;
		display->dispsw_data = info->fbcon_cmap.cfb16;
		break;
#endif
#ifdef FBCON_HAS_CFB32
	     case CMODE_32:
		display->dispsw = &fbcon_cfb32;
		display->dispsw_data = info->fbcon_cmap.cfb32;
		break;
#endif
	     default:
		display->dispsw = &fbcon_dummy;
		break;
	    }
	    
	    display->scrollmode = SCROLL_YREDRAW;
	    if (info->fb_info.changevar)
	      (*info->fb_info.changevar)(con);
	}

	if (con == currcon)
		platinum_set_par(&par, info);

	if (oldbpp != var->bits_per_pixel) {
	    if ((err = fb_alloc_cmap(&display->cmap, 0, 0)))
	      return err;
	    do_install_cmap(con, &info->fb_info);
	}

	return 0;
}

static int platinum_pan_display(struct fb_var_screeninfo *var, int con,
				struct fb_info *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.
     */

	if (var->xoffset != 0 || var->yoffset != 0)
		return -EINVAL;
	return 0;
}

static int platinum_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, platinum_getcolreg, info);
	if (fb_display[con].cmap.len)	/* non default colormap? */
		fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
	else {
		int size = fb_display[con].var.bits_per_pixel == 16 ? 32 : 256;
		fb_copy_cmap(fb_default_cmap(size), cmap, kspc ? 0 : 2);
	}
	return 0;
}

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

	if (!fb_display[con].cmap.len) {
		int size = fb_display[con].var.bits_per_pixel == 16 ? 32 : 256;
		err = fb_alloc_cmap(&fb_display[con].cmap, size, 0);
		if (err)
			return err;
	}

	if (con == currcon)
		return fb_set_cmap(cmap, kspc, platinum_setcolreg, info);
	fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
	return 0;
}

static int platinum_ioctl(struct inode *inode, struct file *file, u_int cmd,
			  u_long arg, int con, struct fb_info *info)
{
	printk(KERN_ERR "platinum_ioctl not yet implemented\n");
	return -EINVAL;
}

static int platinum_switch(int con, struct fb_info *fb)
{
	struct fb_info_platinum *info = (struct fb_info_platinum *) fb;
	struct fb_par_platinum par;

	if (fb_display[currcon].cmap.len)
		fb_get_cmap(&fb_display[currcon].cmap, 1, platinum_getcolreg,
			    fb);
	currcon = con;

	platinum_var_to_par(&fb_display[currcon].var, &par, info);
	platinum_set_par(&par, info);
	do_install_cmap(con, fb);

	return 1;
}

static int platinum_updatevar(int con, struct fb_info *fb)
{
	printk(KERN_ERR "platinum_updatevar is doing nothing yet.\n");
	return 0;
}

static void platinum_blank(int blank,  struct fb_info *fb)
{
/*
 *  Blank the screen if blank_mode != 0, else unblank. If blank == NULL
 *  then the caller blanks by setting the CLUT (Color Look Up Table) to all
 *  black. Return 0 if blanking succeeded, != 0 if un-/blanking failed due
 *  to e.g. a video mode which doesn't support it. Implements VESA suspend
 *  and powerdown modes on hardware that supports disabling hsync/vsync:
 *    blank_mode == 2: suspend vsync
 *    blank_mode == 3: suspend hsync
 *    blank_mode == 4: powerdown
 */
/* [danj] I think there's something fishy about those constants... */
/*
	struct fb_info_platinum *info = (struct fb_info_platinum *) fb;
	int	ctrl;

	ctrl = ld_le32(&info->platinum_regs->ctrl.r) | 0x33;
	if (blank)
		--blank_mode;
	if (blank & VESA_VSYNC_SUSPEND)
		ctrl &= ~3;
	if (blank & VESA_HSYNC_SUSPEND)
		ctrl &= ~0x30;
	out_le32(&info->platinum_regs->ctrl.r, ctrl);
*/
/* TODO: Figure out how the heck to powerdown this thing! */
    return;
}

static int platinum_getcolreg(u_int regno, u_int *red, u_int *green,
			      u_int *blue, u_int *transp, struct fb_info *fb)
{
	struct fb_info_platinum *info = (struct fb_info_platinum *) fb;

	if (regno > 255)
		return 1;

	*red = (info->palette[regno].red<<8) | info->palette[regno].red;
	*green = (info->palette[regno].green<<8) | info->palette[regno].green;
	*blue = (info->palette[regno].blue<<8) | info->palette[regno].blue;
	*transp = 0;
	return 0;
}

static int platinum_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
			      u_int transp, struct fb_info *fb)
{
	struct fb_info_platinum *info = (struct fb_info_platinum *) fb;
	volatile struct cmap_regs *cmap_regs = info->cmap_regs;
	/* int scale; */

	if (regno > 255)
		return 1;

	red >>= 8;
	green >>= 8;
	blue >>= 8;

	info->palette[regno].red = red;
	info->palette[regno].green = green;
	info->palette[regno].blue = blue;

	/* scale = (info->current_par.cmode == CMODE_16) ? 3 : 0; */

	out_8(&cmap_regs->addr, regno);		/* tell clut what addr to fill	*/
	out_8(&cmap_regs->lut, red);	/* send one color channel at	*/
	out_8(&cmap_regs->lut, green);	/* a time...			*/
	out_8(&cmap_regs->lut, blue);

	if(regno < 16) {
#ifdef FBCON_HAS_CFB16
		info->fbcon_cmap.cfb16[regno] = (regno << 10) | (regno << 5) | (regno << 0);
#endif
#ifdef FBCON_HAS_CFB32
		info->fbcon_cmap.cfb32[regno] = (regno << 24) | (regno << 16) | (regno << 8) | regno;
#endif
	}
	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, platinum_setcolreg,
			    info);
	else {
		int size = fb_display[con].var.bits_per_pixel == 16 ? 32 : 256;
		fb_set_cmap(fb_default_cmap(size), 1, platinum_setcolreg,
			    info);
	}
}

static inline int platinum_vram_reqd(int video_mode, int color_mode)
{
	return vmode_attrs[video_mode-1].vres *
	       (vmode_attrs[video_mode-1].hres * (1<<color_mode) + 0x20) +0x1000;
}

#define STORE_D2(a, d) { \
	out_8(&cmap_regs->addr, (a+32)); \
	out_8(&cmap_regs->d2, (d)); \
}

static void set_platinum_clock(struct fb_info_platinum *info)
{
	volatile struct cmap_regs *cmap_regs = info->cmap_regs;
	struct platinum_regvals	*init;

	init = platinum_reg_init[info->current_par.vmode-1];

	STORE_D2(6, 0xc6);
	out_8(&cmap_regs->addr,3+32);

	if (in_8(&cmap_regs->d2) == 2) {
		STORE_D2(7, init->clock_params[info->clktype][0]);
		STORE_D2(8, init->clock_params[info->clktype][1]);
		STORE_D2(3, 3);
	} else {
		STORE_D2(4, init->clock_params[info->clktype][0]);
		STORE_D2(5, init->clock_params[info->clktype][1]);
		STORE_D2(3, 2);
	}

	__delay(5000);
	STORE_D2(9, 0xa6);
}


/* Now how about actually saying, Make it so! */
/* Some things in here probably don't need to be done each time. */
static void platinum_set_par(const struct fb_par_platinum *par, struct fb_info_platinum *info)
{
	volatile struct platinum_regs	*platinum_regs = info->platinum_regs;
	volatile struct cmap_regs	*cmap_regs = info->cmap_regs;
	struct platinum_regvals		*init;
	int				i;
	int				vmode, cmode;
	
	info->current_par = *par;

	vmode = par->vmode;
	cmode = par->cmode;

	init = platinum_reg_init[vmode - 1];

	/* Initialize display timing registers */
	out_be32(&platinum_regs->reg[24].r, 7);	/* turn display off */

	for (i = 0; i < 26; ++i)
		out_be32(&platinum_regs->reg[i+32].r, init->regs[i]);

	out_be32(&platinum_regs->reg[26+32].r, (info->total_vram == 0x100000 ?
						init->offset[cmode] + 4 - cmode :
						init->offset[cmode]));
	/*out_be32(&platinum_regs->reg[16].r, (unsigned) info->frame_buffer_phys + 0x1000 - 0x10);*/
	out_be32(&platinum_regs->reg[16].r, (unsigned) info->frame_buffer_phys+init->fb_offset+0x10);
	out_be32(&platinum_regs->reg[18].r, init->pitch[cmode]);
	out_be32(&platinum_regs->reg[19].r, (info->total_vram == 0x100000 ?
					     init->mode[cmode+1] :
					     init->mode[cmode]));
	out_be32(&platinum_regs->reg[20].r, (info->total_vram == 0x100000 ? 0x11 : 0x1011));
	out_be32(&platinum_regs->reg[21].r, 0x100);
	out_be32(&platinum_regs->reg[22].r, 1);
	out_be32(&platinum_regs->reg[23].r, 1);
	out_be32(&platinum_regs->reg[26].r, 0xc00);
	out_be32(&platinum_regs->reg[27].r, 0x235);
	/* out_be32(&platinum_regs->reg[27].r, 0x2aa); */

	STORE_D2(0, (info->total_vram == 0x100000 ?
		     init->dacula_ctrl[cmode] & 0xf :
		     init->dacula_ctrl[cmode]));
	STORE_D2(1, 4);
	STORE_D2(2, 0);

	set_platinum_clock(info);

	out_be32(&platinum_regs->reg[24].r, 0);	/* turn display on */

#ifdef CONFIG_FB_COMPAT_XPMAC
	if (console_fb_info == &info->fb_info) {
		display_info.height = par->yres;
		display_info.width = par->xres;
		display_info.depth = ( (cmode == CMODE_32) ? 32 :
				      ((cmode == CMODE_16) ? 16 : 8));
		display_info.pitch = vmode_attrs[vmode-1].hres * (1<<cmode) + 0x20;
		display_info.mode = vmode;
		strncpy(display_info.name, "platinum",
			sizeof(display_info.name));
		/*display_info.fb_address = info->frame_buffer_phys + 0x1000;*/
		display_info.fb_address = info->frame_buffer_phys + init->fb_offset + 0x20;
		display_info.cmap_adr_address = info->cmap_regs_phys;
		display_info.cmap_data_address = info->cmap_regs_phys + 0x30;
		display_info.disp_reg_address = info->platinum_regs_phys;
		
	}
#endif /* CONFIG_FB_COMPAT_XPMAC */
}


__initfunc(static int init_platinum(struct fb_info_platinum *info))
{
	struct fb_var_screeninfo var;
	struct display *disp;
	int sense;
	int j,k;

	sense = read_platinum_sense(info);
	printk(KERN_INFO "Monitor sense value = 0x%x, ", sense);

	if (default_vmode == VMODE_NVRAM) {
		default_vmode = nvram_read_byte(NV_VMODE);
		if (default_vmode <= 0 || default_vmode > VMODE_MAX ||
		    !platinum_reg_init[default_vmode-1])
			default_vmode = VMODE_CHOOSE;
	}
	if (default_vmode == VMODE_CHOOSE) {
		default_vmode = mac_map_monitor_sense(sense);
	}
	if (default_vmode <= 0 || default_vmode > VMODE_MAX)
		default_vmode = VMODE_640_480_60;
	if (default_cmode == CMODE_NVRAM)
		default_cmode = nvram_read_byte(NV_CMODE);
	if (default_cmode < CMODE_8 || default_cmode > CMODE_32)
		default_cmode = CMODE_8;
	/*
	 * Reduce the pixel size if we don't have enough VRAM.
	 */
	while(default_cmode > CMODE_8 && platinum_vram_reqd(default_vmode, default_cmode) > info->total_vram)
		default_cmode--;

	printk("using video mode %d and color mode %d.\n", default_vmode, default_cmode);

	mac_vmode_to_var(default_vmode, default_cmode, &var);

	if (platinum_var_to_par(&var, &info->default_par, info)) {
		printk(KERN_ERR "platinumfb: can't set default video mode\n");
		return 0;
	}

	disp = &info->disp;

	strcpy(info->fb_info.modename, "platinum");
	info->fb_info.node = -1;
	info->fb_info.fbops = &platinumfb_ops;
	info->fb_info.disp = disp;
	strcpy(info->fb_info.fontname, fontname);
	info->fb_info.changevar = NULL;
	info->fb_info.switch_con = &platinum_switch;
	info->fb_info.updatevar = &platinum_updatevar;
	info->fb_info.blank = &platinum_blank;
	info->fb_info.flags = FBINFO_FLAG_DEFAULT;

	for (j = 0; j < 16; j++) {
		k = color_table[j];
		info->palette[j].red = default_red[k];
		info->palette[j].green = default_grn[k];
		info->palette[j].blue = default_blu[k];
	}
	platinum_set_var(&var, -1, &info->fb_info);

	if (register_framebuffer(&info->fb_info) < 0)
		return 0;

	printk(KERN_INFO "fb%d: platinum frame buffer device\n",
	       GET_FB_IDX(info->fb_info.node));

	return 1;
}

__initfunc(void platinum_init(void))
{
#ifndef CONFIG_FB_OF
	struct device_node *dp;

	dp = find_devices("platinum");
	if (dp != 0)
		platinum_of_init(dp);
#endif /* CONFIG_FB_OF */
}

#ifdef __powerpc__
#define invalidate_cache(addr) \
	asm volatile("eieio; dcbf 0,%1" \
	: "=m" (*(addr)) : "r" (addr) : "memory");
#else
#define invalidate_cache(addr)
#endif

__initfunc(void platinum_of_init(struct device_node *dp))
{
	struct fb_info_platinum	*info;
	unsigned long		addr, size;
	int			i, bank0, bank1, bank2, bank3;

	if(dp->n_addrs != 2)
		panic("expecting 2 address for platinum (got %d)", dp->n_addrs);

	info = kmalloc(sizeof(*info), GFP_ATOMIC);
	if (info == 0)
		return;
	memset(info, 0, sizeof(*info));

	/* Map in frame buffer and registers */
	for (i = 0; i < dp->n_addrs; ++i) {
		addr = dp->addrs[i].address;
		size = dp->addrs[i].size;
		if (size >= 0x400000) {
			/* frame buffer - map only 4MB */
			info->frame_buffer_phys = addr;
			info->frame_buffer = __ioremap(addr, 0x400000, _PAGE_WRITETHRU);
			info->base_frame_buffer = info->frame_buffer;
		} else {
			/* registers */
			info->platinum_regs_phys = addr;
			info->platinum_regs = ioremap(addr, size);
		}
	}

	info->cmap_regs_phys = 0xf301b000;	/* XXX not in prom? */
	info->cmap_regs = ioremap(info->cmap_regs_phys, 0x1000);

	/* Grok total video ram */
	out_be32(&info->platinum_regs->reg[16].r, (unsigned)info->frame_buffer_phys);
	out_be32(&info->platinum_regs->reg[20].r, 0x1011);	/* select max vram */
	out_be32(&info->platinum_regs->reg[24].r, 0);	/* switch in vram */

	info->base_frame_buffer[0x100000] = 0x34;
	info->base_frame_buffer[0x100008] = 0x0;
	invalidate_cache(&info->base_frame_buffer[0x100000]);
	info->base_frame_buffer[0x200000] = 0x56;
	info->base_frame_buffer[0x200008] = 0x0;
	invalidate_cache(&info->base_frame_buffer[0x200000]);
	info->base_frame_buffer[0x300000] = 0x78;
	info->base_frame_buffer[0x300008] = 0x0;
	invalidate_cache(&info->base_frame_buffer[0x300000]);
	bank0 = 1; /* builtin 1MB vram, always there */
	bank1 = info->base_frame_buffer[0x100000] == 0x34;
	bank2 = info->base_frame_buffer[0x200000] == 0x56;
	bank3 = info->base_frame_buffer[0x300000] == 0x78;
	info->total_vram = (bank0 + bank1 + bank2 + bank3) * 0x100000;
	printk(KERN_INFO "Total VRAM = %dMB %d%d%d%d\n", (int) (info->total_vram / 1024 / 1024), bank3, bank2, bank1, bank0);

	/*
	 * Try to determine whether we have an old or a new DACula.
	 */
	out_8(&info->cmap_regs->addr, 0x40);
	info->dactype = in_8(&info->cmap_regs->d2);
	switch (info->dactype) {
	case 0x3c:
		info->clktype = 1;
		break;
	case 0x84:
		info->clktype = 0;
		break;
	default:
		info->clktype = 0;
		printk(KERN_INFO "Unknown DACula type: %x\n", info->dactype);
		break;
	}

	if (!init_platinum(info)) {
		kfree(info);
		return;
	}

#ifdef CONFIG_FB_COMPAT_XPMAC
	if (!console_fb_info)
		console_fb_info = &info->fb_info;
#endif
}

/*
 * Get the monitor sense value.
 * Note that this can be called before calibrate_delay,
 * so we can't use udelay.
 */
static int read_platinum_sense(struct fb_info_platinum *info)
{
	volatile struct platinum_regs *platinum_regs = info->platinum_regs;
	int sense;

	out_be32(&platinum_regs->reg[23].r, 7);	/* turn off drivers */
	__delay(2000);
	sense = (~in_be32(&platinum_regs->reg[23].r) & 7) << 8;

	/* drive each sense line low in turn and collect the other 2 */
	out_be32(&platinum_regs->reg[23].r, 3);	/* drive A low */
	__delay(2000);
	sense |= (~in_be32(&platinum_regs->reg[23].r) & 3) << 4;
	out_be32(&platinum_regs->reg[23].r, 5);	/* drive B low */
	__delay(2000);
	sense |= (~in_be32(&platinum_regs->reg[23].r) & 4) << 1;
	sense |= (~in_be32(&platinum_regs->reg[23].r) & 1) << 2;
	out_be32(&platinum_regs->reg[23].r, 6);	/* drive C low */
	__delay(2000);
	sense |= (~in_be32(&platinum_regs->reg[23].r) & 6) >> 1;

	out_be32(&platinum_regs->reg[23].r, 7);	/* turn off drivers */

	return sense;
}

/* This routine takes a user-supplied var, and picks the best vmode/cmode from it. */
static int platinum_var_to_par(const struct fb_var_screeninfo *var, 
			       struct fb_par_platinum *par,
			       const struct fb_info_platinum *info)
{
	if(mac_var_to_vmode(var, &par->vmode, &par->cmode) != 0) {
		printk(KERN_ERR "platinum_var_to_par: mac_var_to_vmode unsuccessful.\n");
		printk(KERN_ERR "platinum_var_to_par: var->xres = %d\n", var->xres);
		printk(KERN_ERR "platinum_var_to_par: var->yres = %d\n", var->yres);
		printk(KERN_ERR "platinum_var_to_par: var->xres_virtual = %d\n", var->xres_virtual);
		printk(KERN_ERR "platinum_var_to_par: var->yres_virtual = %d\n", var->yres_virtual);
		printk(KERN_ERR "platinum_var_to_par: var->bits_per_pixel = %d\n", var->bits_per_pixel);
		printk(KERN_ERR "platinum_var_to_par: var->pixclock = %d\n", var->pixclock);
		printk(KERN_ERR "platinum_var_to_par: var->vmode = %d\n", var->vmode);
		return -EINVAL;
	}

	if(!platinum_reg_init[par->vmode-1]) {
		printk(KERN_ERR "platinum_var_to_par, vmode %d not valid.\n", par->vmode);
		return -EINVAL;
	}

	if (platinum_vram_reqd(par->vmode, par->cmode) > info->total_vram) {
		printk(KERN_ERR "platinum_var_to_par, not enough ram for vmode %d, cmode %d.\n", par->vmode, par->cmode);
		return -EINVAL;
	}

	par->xres = vmode_attrs[par->vmode-1].hres;
	par->yres = vmode_attrs[par->vmode-1].vres;
	par->xoffset = 0;
	par->yoffset = 0;
	par->vxres = par->xres;
	par->vyres = par->yres;
	
	return 0;
}

static int platinum_par_to_var(struct fb_var_screeninfo *var,
			       const struct fb_par_platinum *par,
			       const struct fb_info_platinum *info)
{
	return mac_vmode_to_var(par->vmode, par->cmode, var);
}

static int platinum_encode_fix(struct fb_fix_screeninfo *fix,
			       const struct fb_par_platinum *par,
			       const struct fb_info_platinum *info)
{
        struct platinum_regvals *init;

        init = platinum_reg_init[par->vmode-1];

	memset(fix, 0, sizeof(*fix));
	strcpy(fix->id, "platinum");
	/*fix->smem_start = (void *) (info->frame_buffer_phys + 0x1000);*/
	fix->smem_start = (void *) (info->frame_buffer_phys) + init->fb_offset + 0x20;
	/*fix->smem_len = (u32) info->total_vram - 0x1000;*/
	fix->smem_len = (u32) info->total_vram;
	/*
	fix->mmio_start = (char *) (info->platinum_regs_phys);
	fix->mmio_len = 0x1000;
	*/
	fix->type = FB_TYPE_PACKED_PIXELS;
	fix->type_aux = 0;
	fix->ywrapstep = 0;
	fix->xpanstep = 0;
	fix->ypanstep = 0;
	fix->visual = (par->cmode == CMODE_8) ?
		FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
	fix->line_length = vmode_attrs[par->vmode-1].hres * (1<<par->cmode) + 0x20;

	return 0;
}


/* 
 * Parse user speficied options (`video=platinumfb:')
 */
__initfunc(void platinum_setup(char *options, int *ints))
{
	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 8:
			    default_cmode = CMODE_8;
			    break;
			 case 15:
			 case 16:
			    default_cmode = CMODE_16;
			    break;
			 case 24:
			 case 32:
			    default_cmode = CMODE_32;
			    break;
			}
		}
	}
}

--L2Brqb15TUChFOBK--

[[ This message was sent via the linuxppc-dev mailing list.  Replies are ]]
[[ not  forced  back  to the list, so be sure to Cc linuxppc-dev if your ]]
[[ reply is of general interest. Please check http://lists.linuxppc.org/ ]]
[[ and http://www.linuxppc.org/ for useful information before posting.   ]]