[mirror_ubuntu-bionic-kernel.git] / drivers / video / cg14.c

/* cg14.c: CGFOURTEEN frame buffer driver
 *
 * Copyright (C) 2003, 2006 David S. Miller (davem@davemloft.net)
 * Copyright (C) 1996,1998 Jakub Jelinek (jj@ultra.linux.cz)
 * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
 *
 * Driver layout based loosely on tgafb.c, see that file for credits.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/fb.h>
#include <linux/mm.h>
#include <linux/uaccess.h>

#include <asm/io.h>
#include <asm/prom.h>
#include <asm/of_device.h>
#include <asm/fbio.h>

#include "sbuslib.h"

/*
 * Local functions.
 */

static int cg14_setcolreg(unsigned, unsigned, unsigned, unsigned,
			 unsigned, struct fb_info *);

static int cg14_mmap(struct fb_info *, struct vm_area_struct *);
static int cg14_ioctl(struct fb_info *, unsigned int, unsigned long);
static int cg14_pan_display(struct fb_var_screeninfo *, struct fb_info *);

/*
 *  Frame buffer operations
 */

static struct fb_ops cg14_ops = {
	.owner			= THIS_MODULE,
	.fb_setcolreg		= cg14_setcolreg,
	.fb_pan_display		= cg14_pan_display,
	.fb_fillrect		= cfb_fillrect,
	.fb_copyarea		= cfb_copyarea,
	.fb_imageblit		= cfb_imageblit,
	.fb_mmap		= cg14_mmap,
	.fb_ioctl		= cg14_ioctl,
#ifdef CONFIG_COMPAT
	.fb_compat_ioctl	= sbusfb_compat_ioctl,
#endif
};

#define CG14_MCR_INTENABLE_SHIFT	7
#define CG14_MCR_INTENABLE_MASK		0x80
#define CG14_MCR_VIDENABLE_SHIFT	6
#define CG14_MCR_VIDENABLE_MASK		0x40
#define CG14_MCR_PIXMODE_SHIFT		4
#define CG14_MCR_PIXMODE_MASK		0x30
#define CG14_MCR_TMR_SHIFT		2
#define CG14_MCR_TMR_MASK		0x0c
#define CG14_MCR_TMENABLE_SHIFT		1
#define CG14_MCR_TMENABLE_MASK		0x02
#define CG14_MCR_RESET_SHIFT		0
#define CG14_MCR_RESET_MASK		0x01
#define CG14_REV_REVISION_SHIFT		4
#define CG14_REV_REVISION_MASK		0xf0
#define CG14_REV_IMPL_SHIFT		0
#define CG14_REV_IMPL_MASK		0x0f
#define CG14_VBR_FRAMEBASE_SHIFT	12
#define CG14_VBR_FRAMEBASE_MASK		0x00fff000
#define CG14_VMCR1_SETUP_SHIFT		0
#define CG14_VMCR1_SETUP_MASK		0x000001ff
#define CG14_VMCR1_VCONFIG_SHIFT	9
#define CG14_VMCR1_VCONFIG_MASK		0x00000e00
#define CG14_VMCR2_REFRESH_SHIFT	0
#define CG14_VMCR2_REFRESH_MASK		0x00000001
#define CG14_VMCR2_TESTROWCNT_SHIFT	1
#define CG14_VMCR2_TESTROWCNT_MASK	0x00000002
#define CG14_VMCR2_FBCONFIG_SHIFT	2
#define CG14_VMCR2_FBCONFIG_MASK	0x0000000c
#define CG14_VCR_REFRESHREQ_SHIFT	0
#define CG14_VCR_REFRESHREQ_MASK	0x000003ff
#define CG14_VCR1_REFRESHENA_SHIFT	10
#define CG14_VCR1_REFRESHENA_MASK	0x00000400
#define CG14_VCA_CAD_SHIFT		0
#define CG14_VCA_CAD_MASK		0x000003ff
#define CG14_VCA_VERS_SHIFT		10
#define CG14_VCA_VERS_MASK		0x00000c00
#define CG14_VCA_RAMSPEED_SHIFT		12
#define CG14_VCA_RAMSPEED_MASK		0x00001000
#define CG14_VCA_8MB_SHIFT		13
#define CG14_VCA_8MB_MASK		0x00002000

#define CG14_MCR_PIXMODE_8		0
#define CG14_MCR_PIXMODE_16		2
#define CG14_MCR_PIXMODE_32		3

struct cg14_regs{
	u8 mcr;	/* Master Control Reg */
	u8 ppr;	/* Packed Pixel Reg */
	u8 tms[2];	/* Test Mode Status Regs */
	u8 msr;	/* Master Status Reg */
	u8 fsr;	/* Fault Status Reg */
	u8 rev;	/* Revision & Impl */
	u8 ccr;	/* Clock Control Reg */
	u32 tmr;	/* Test Mode Read Back */
	u8 mod;	/* Monitor Operation Data Reg */
	u8 acr;	/* Aux Control */
	u8 xxx0[6];
	u16 hct;	/* Hor Counter */
	u16 vct;	/* Vert Counter */
	u16 hbs;	/* Hor Blank Start */
	u16 hbc;	/* Hor Blank Clear */
	u16 hss;	/* Hor Sync Start */
	u16 hsc;	/* Hor Sync Clear */
	u16 csc;	/* Composite Sync Clear */
	u16 vbs;	/* Vert Blank Start */
	u16 vbc;	/* Vert Blank Clear */
	u16 vss;	/* Vert Sync Start */
	u16 vsc;	/* Vert Sync Clear */
	u16 xcs;
	u16 xcc;
	u16 fsa;	/* Fault Status Address */
	u16 adr;	/* Address Registers */
	u8 xxx1[0xce];
	u8 pcg[0x100]; /* Pixel Clock Generator */
	u32 vbr;	/* Frame Base Row */
	u32 vmcr;	/* VBC Master Control */
	u32 vcr;	/* VBC refresh */
	u32 vca;	/* VBC Config */
};

#define CG14_CCR_ENABLE	0x04
#define CG14_CCR_SELECT 0x02	/* HW/Full screen */

struct cg14_cursor {
	u32 cpl0[32];	/* Enable plane 0 */
	u32 cpl1[32];  /* Color selection plane */
	u8 ccr;	/* Cursor Control Reg */
	u8 xxx0[3];
	u16 cursx;	/* Cursor x,y position */
	u16 cursy;	/* Cursor x,y position */
	u32 color0;
	u32 color1;
	u32 xxx1[0x1bc];
	u32 cpl0i[32];	/* Enable plane 0 autoinc */
	u32 cpl1i[32]; /* Color selection autoinc */
};

struct cg14_dac {
	u8 addr;	/* Address Register */
	u8 xxx0[255];
	u8 glut;	/* Gamma table */
	u8 xxx1[255];
	u8 select;	/* Register Select */
	u8 xxx2[255];
	u8 mode;	/* Mode Register */
};

struct cg14_xlut{
	u8 x_xlut [256];
	u8 x_xlutd [256];
	u8 xxx0[0x600];
	u8 x_xlut_inc [256];
	u8 x_xlutd_inc [256];
};

/* Color look up table (clut) */
/* Each one of these arrays hold the color lookup table (for 256
 * colors) for each MDI page (I assume then there should be 4 MDI
 * pages, I still wonder what they are.  I have seen NeXTStep split
 * the screen in four parts, while operating in 24 bits mode.  Each
 * integer holds 4 values: alpha value (transparency channel, thanks
 * go to John Stone (johns@umr.edu) from OpenBSD), red, green and blue
 *
 * I currently use the clut instead of the Xlut
 */
struct cg14_clut {
	u32 c_clut [256];
	u32 c_clutd [256];    /* i wonder what the 'd' is for */
	u32 c_clut_inc [256];
	u32 c_clutd_inc [256];
};

#define CG14_MMAP_ENTRIES	16

struct cg14_par {
	spinlock_t		lock;
	struct cg14_regs	__iomem *regs;
	struct cg14_clut	__iomem *clut;
	struct cg14_cursor	__iomem *cursor;

	u32			flags;
#define CG14_FLAG_BLANKED	0x00000001

	unsigned long		physbase;
	unsigned long		iospace;
	unsigned long		fbsize;

	struct sbus_mmap_map	mmap_map[CG14_MMAP_ENTRIES];

	int			mode;
	int			ramsize;
};

static void __cg14_reset(struct cg14_par *par)
{
	struct cg14_regs __iomem *regs = par->regs;
	u8 val;

	val = sbus_readb(&regs->mcr);
	val &= ~(CG14_MCR_PIXMODE_MASK);
	sbus_writeb(val, &regs->mcr);
}

static int cg14_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
{
	struct cg14_par *par = (struct cg14_par *) info->par;
	unsigned long flags;

	/* We just use this to catch switches out of
	 * graphics mode.
	 */
	spin_lock_irqsave(&par->lock, flags);
	__cg14_reset(par);
	spin_unlock_irqrestore(&par->lock, flags);

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

/**
 *      cg14_setcolreg - Optional function. Sets a color register.
 *      @regno: boolean, 0 copy local, 1 get_user() function
 *      @red: frame buffer colormap structure
 *      @green: The green value which can be up to 16 bits wide
 *      @blue:  The blue value which can be up to 16 bits wide.
 *      @transp: If supported the alpha value which can be up to 16 bits wide.
 *      @info: frame buffer info structure
 */
static int cg14_setcolreg(unsigned regno,
			  unsigned red, unsigned green, unsigned blue,
			  unsigned transp, struct fb_info *info)
{
	struct cg14_par *par = (struct cg14_par *) info->par;
	struct cg14_clut __iomem *clut = par->clut;
	unsigned long flags;
	u32 val;

	if (regno >= 256)
		return 1;

	red >>= 8;
	green >>= 8;
	blue >>= 8;
	val = (red | (green << 8) | (blue << 16));

	spin_lock_irqsave(&par->lock, flags);
	sbus_writel(val, &clut->c_clut[regno]);
	spin_unlock_irqrestore(&par->lock, flags);

	return 0;
}

static int cg14_mmap(struct fb_info *info, struct vm_area_struct *vma)
{
	struct cg14_par *par = (struct cg14_par *) info->par;

	return sbusfb_mmap_helper(par->mmap_map,
				  par->physbase, par->fbsize,
				  par->iospace, vma);
}

static int cg14_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
{
	struct cg14_par *par = (struct cg14_par *) info->par;
	struct cg14_regs __iomem *regs = par->regs;
	struct mdi_cfginfo kmdi, __user *mdii;
	unsigned long flags;
	int cur_mode, mode, ret = 0;

	switch (cmd) {
	case MDI_RESET:
		spin_lock_irqsave(&par->lock, flags);
		__cg14_reset(par);
		spin_unlock_irqrestore(&par->lock, flags);
		break;

	case MDI_GET_CFGINFO:
		memset(&kmdi, 0, sizeof(kmdi));

		spin_lock_irqsave(&par->lock, flags);
		kmdi.mdi_type = FBTYPE_MDICOLOR;
		kmdi.mdi_height = info->var.yres;
		kmdi.mdi_width = info->var.xres;
		kmdi.mdi_mode = par->mode;
		kmdi.mdi_pixfreq = 72; /* FIXME */
		kmdi.mdi_size = par->ramsize;
		spin_unlock_irqrestore(&par->lock, flags);

		mdii = (struct mdi_cfginfo __user *) arg;
		if (copy_to_user(mdii, &kmdi, sizeof(kmdi)))
			ret = -EFAULT;
		break;

	case MDI_SET_PIXELMODE:
		if (get_user(mode, (int __user *) arg)) {
			ret = -EFAULT;
			break;
		}

		spin_lock_irqsave(&par->lock, flags);
		cur_mode = sbus_readb(&regs->mcr);
		cur_mode &= ~CG14_MCR_PIXMODE_MASK;
		switch(mode) {
		case MDI_32_PIX:
			cur_mode |= (CG14_MCR_PIXMODE_32 <<
				     CG14_MCR_PIXMODE_SHIFT);
			break;

		case MDI_16_PIX:
			cur_mode |= (CG14_MCR_PIXMODE_16 <<
				     CG14_MCR_PIXMODE_SHIFT);
			break;

		case MDI_8_PIX:
			break;

		default:
			ret = -ENOSYS;
			break;
		};
		if (!ret) {
			sbus_writeb(cur_mode, &regs->mcr);
			par->mode = mode;
		}
		spin_unlock_irqrestore(&par->lock, flags);
		break;

	default:
		ret = sbusfb_ioctl_helper(cmd, arg, info,
					  FBTYPE_MDICOLOR, 8, par->fbsize);
		break;
	};

	return ret;
}

/*
 *  Initialisation
 */

static void __devinit cg14_init_fix(struct fb_info *info, int linebytes,
				    struct device_node *dp)
{
	const char *name = dp->name;

	strlcpy(info->fix.id, name, sizeof(info->fix.id));

	info->fix.type = FB_TYPE_PACKED_PIXELS;
	info->fix.visual = FB_VISUAL_PSEUDOCOLOR;

	info->fix.line_length = linebytes;

	info->fix.accel = FB_ACCEL_SUN_CG14;
}

static struct sbus_mmap_map __cg14_mmap_map[CG14_MMAP_ENTRIES] __devinitdata = {
	{
		.voff	= CG14_REGS,
		.poff	= 0x80000000,
		.size	= 0x1000
	},
	{
		.voff	= CG14_XLUT,
		.poff	= 0x80003000,
		.size	= 0x1000
	},
	{
		.voff	= CG14_CLUT1,
		.poff	= 0x80004000,
		.size	= 0x1000
	},
	{
		.voff	= CG14_CLUT2,
		.poff	= 0x80005000,
		.size	= 0x1000
	},
	{
		.voff	= CG14_CLUT3,
		.poff	= 0x80006000,
		.size	= 0x1000
	},
	{
		.voff	= CG3_MMAP_OFFSET - 0x7000,
		.poff	= 0x80000000,
		.size	= 0x7000
	},
	{
		.voff	= CG3_MMAP_OFFSET,
		.poff	= 0x00000000,
		.size	= SBUS_MMAP_FBSIZE(1)
	},
	{
		.voff	= MDI_CURSOR_MAP,
		.poff	= 0x80001000,
		.size	= 0x1000
	},
	{
		.voff	= MDI_CHUNKY_BGR_MAP,
		.poff	= 0x01000000,
		.size	= 0x400000
	},
	{
		.voff	= MDI_PLANAR_X16_MAP,
		.poff	= 0x02000000,
		.size	= 0x200000
	},
	{
		.voff	= MDI_PLANAR_C16_MAP,
		.poff	= 0x02800000,
		.size	= 0x200000
	},
	{
		.voff	= MDI_PLANAR_X32_MAP,
		.poff	= 0x03000000,
		.size	= 0x100000
	},
	{
		.voff	= MDI_PLANAR_B32_MAP,
		.poff	= 0x03400000,
		.size	= 0x100000
	},
	{
		.voff	= MDI_PLANAR_G32_MAP,
		.poff	= 0x03800000,
		.size	= 0x100000
	},
	{
		.voff	= MDI_PLANAR_R32_MAP,
		.poff	= 0x03c00000,
		.size	= 0x100000
	},
	{ .size = 0 }
};

static void cg14_unmap_regs(struct of_device *op, struct fb_info *info,
			    struct cg14_par *par)
{
	if (par->regs)
		of_iounmap(&op->resource[0],
			   par->regs, sizeof(struct cg14_regs));
	if (par->clut)
		of_iounmap(&op->resource[0],
			   par->clut, sizeof(struct cg14_clut));
	if (par->cursor)
		of_iounmap(&op->resource[0],
			   par->cursor, sizeof(struct cg14_cursor));
	if (info->screen_base)
		of_iounmap(&op->resource[1],
			   info->screen_base, par->fbsize);
}

static int __devinit cg14_probe(struct of_device *op, const struct of_device_id *match)
{
	struct device_node *dp = op->node;
	struct fb_info *info;
	struct cg14_par *par;
	int is_8mb, linebytes, i, err;

	info = framebuffer_alloc(sizeof(struct cg14_par), &op->dev);

	err = -ENOMEM;
	if (!info)
		goto out_err;
	par = info->par;

	spin_lock_init(&par->lock);

	sbusfb_fill_var(&info->var, dp->node, 8);
	info->var.red.length = 8;
	info->var.green.length = 8;
	info->var.blue.length = 8;

	linebytes = of_getintprop_default(dp, "linebytes",
					  info->var.xres);
	par->fbsize = PAGE_ALIGN(linebytes * info->var.yres);

	if (!strcmp(dp->parent->name, "sbus") ||
	    !strcmp(dp->parent->name, "sbi")) {
		par->physbase = op->resource[0].start;
		par->iospace = op->resource[0].flags & IORESOURCE_BITS;
	} else {
		par->physbase = op->resource[1].start;
		par->iospace = op->resource[0].flags & IORESOURCE_BITS;
	}

	par->regs = of_ioremap(&op->resource[0], 0,
			       sizeof(struct cg14_regs), "cg14 regs");
	par->clut = of_ioremap(&op->resource[0], CG14_CLUT1,
			       sizeof(struct cg14_clut), "cg14 clut");
	par->cursor = of_ioremap(&op->resource[0], CG14_CURSORREGS,
				 sizeof(struct cg14_cursor), "cg14 cursor");

	info->screen_base = of_ioremap(&op->resource[1], 0,
				       par->fbsize, "cg14 ram");

	if (!par->regs || !par->clut || !par->cursor || !info->screen_base)
		goto out_unmap_regs;

	is_8mb = (((op->resource[1].end - op->resource[1].start) + 1) ==
		  (8 * 1024 * 1024));

	BUILD_BUG_ON(sizeof(par->mmap_map) != sizeof(__cg14_mmap_map));
		
	memcpy(&par->mmap_map, &__cg14_mmap_map, sizeof(par->mmap_map));

	for (i = 0; i < CG14_MMAP_ENTRIES; i++) {
		struct sbus_mmap_map *map = &par->mmap_map[i];

		if (!map->size)
			break;
		if (map->poff & 0x80000000)
			map->poff = (map->poff & 0x7fffffff) +
				(op->resource[0].start -
				 op->resource[1].start);
		if (is_8mb &&
		    map->size >= 0x100000 &&
		    map->size <= 0x400000)
			map->size *= 2;
	}

	par->mode = MDI_8_PIX;
	par->ramsize = (is_8mb ? 0x800000 : 0x400000);

	info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
	info->fbops = &cg14_ops;

	__cg14_reset(par);

	if (fb_alloc_cmap(&info->cmap, 256, 0))
		goto out_unmap_regs;

	fb_set_cmap(&info->cmap, info);

	cg14_init_fix(info, linebytes, dp);

	err = register_framebuffer(info);
	if (err < 0)
		goto out_dealloc_cmap;

	dev_set_drvdata(&op->dev, info);

	printk("%s: cgfourteen at %lx:%lx, %dMB\n",
	       dp->full_name,
	       par->iospace, par->physbase,
	       par->ramsize >> 20);

	return 0;

out_dealloc_cmap:
	fb_dealloc_cmap(&info->cmap);

out_unmap_regs:
	cg14_unmap_regs(op, info, par);

out_err:
	return err;
}

static int __devexit cg14_remove(struct of_device *op)
{
	struct fb_info *info = dev_get_drvdata(&op->dev);
	struct cg14_par *par = info->par;

	unregister_framebuffer(info);
	fb_dealloc_cmap(&info->cmap);

	cg14_unmap_regs(op, info, par);

	framebuffer_release(info);

	dev_set_drvdata(&op->dev, NULL);

	return 0;
}

static struct of_device_id cg14_match[] = {
	{
		.name = "cgfourteen",
	},
	{},
};
MODULE_DEVICE_TABLE(of, cg14_match);

static struct of_platform_driver cg14_driver = {
	.name		= "cg14",
	.match_table	= cg14_match,
	.probe		= cg14_probe,
	.remove		= __devexit_p(cg14_remove),
};

int __init cg14_init(void)
{
	if (fb_get_options("cg14fb", NULL))
		return -ENODEV;

	return of_register_driver(&cg14_driver, &of_bus_type);
}

void __exit cg14_exit(void)
{
	of_unregister_driver(&cg14_driver);
}

module_init(cg14_init);
module_exit(cg14_exit);

MODULE_DESCRIPTION("framebuffer driver for CGfourteen chipsets");
MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
MODULE_VERSION("2.0");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/* cg14.c: CGFOURTEEN frame buffer driver
1da177e4 LT	2	*
50312ce9	3	* Copyright (C) 2003, 2006 David S. Miller (davem@davemloft.net)
1da177e4 LT	4	* Copyright (C) 1996,1998 Jakub Jelinek (jj@ultra.linux.cz)
	5	* Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
	6	*
	7	* Driver layout based loosely on tgafb.c, see that file for credits.
	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/kernel.h>
	12	#include <linux/errno.h>
	13	#include <linux/string.h>
	14	#include <linux/slab.h>
	15	#include <linux/delay.h>
	16	#include <linux/init.h>
	17	#include <linux/fb.h>
	18	#include <linux/mm.h>
631a9dca	19	#include <linux/uaccess.h>
1da177e4 LT	20
1da177e4 LT	21	#include <asm/io.h>
50312ce9 DM	22	#include <asm/prom.h>
50312ce9 DM	23	#include <asm/of_device.h>
1da177e4 LT	24	#include <asm/fbio.h>
	25
	26	#include "sbuslib.h"
	27
	28	/*
	29	* Local functions.
	30	*/
	31
	32	static int cg14_setcolreg(unsigned, unsigned, unsigned, unsigned,
	33	unsigned, struct fb_info *);
	34
216d526c	35	static int cg14_mmap(struct fb_info , struct vm_area_struct );
67a6680d	36	static int cg14_ioctl(struct fb_info *, unsigned int, unsigned long);
1da177e4 LT	37	static int cg14_pan_display(struct fb_var_screeninfo , struct fb_info );
	38
	39	/*
	40	* Frame buffer operations
	41	*/
	42
	43	static struct fb_ops cg14_ops = {
	44	.owner = THIS_MODULE,
	45	.fb_setcolreg = cg14_setcolreg,
	46	.fb_pan_display = cg14_pan_display,
	47	.fb_fillrect = cfb_fillrect,
	48	.fb_copyarea = cfb_copyarea,
	49	.fb_imageblit = cfb_imageblit,
	50	.fb_mmap = cg14_mmap,
	51	.fb_ioctl = cg14_ioctl,
9ffb83bc CH	52	#ifdef CONFIG_COMPAT
	53	.fb_compat_ioctl = sbusfb_compat_ioctl,
	54	#endif
1da177e4 LT	55	};
	56
	57	#define CG14_MCR_INTENABLE_SHIFT 7
	58	#define CG14_MCR_INTENABLE_MASK 0x80
	59	#define CG14_MCR_VIDENABLE_SHIFT 6
	60	#define CG14_MCR_VIDENABLE_MASK 0x40
	61	#define CG14_MCR_PIXMODE_SHIFT 4
	62	#define CG14_MCR_PIXMODE_MASK 0x30
	63	#define CG14_MCR_TMR_SHIFT 2
	64	#define CG14_MCR_TMR_MASK 0x0c
	65	#define CG14_MCR_TMENABLE_SHIFT 1
	66	#define CG14_MCR_TMENABLE_MASK 0x02
	67	#define CG14_MCR_RESET_SHIFT 0
	68	#define CG14_MCR_RESET_MASK 0x01
	69	#define CG14_REV_REVISION_SHIFT 4
	70	#define CG14_REV_REVISION_MASK 0xf0
	71	#define CG14_REV_IMPL_SHIFT 0
	72	#define CG14_REV_IMPL_MASK 0x0f
	73	#define CG14_VBR_FRAMEBASE_SHIFT 12
	74	#define CG14_VBR_FRAMEBASE_MASK 0x00fff000
	75	#define CG14_VMCR1_SETUP_SHIFT 0
	76	#define CG14_VMCR1_SETUP_MASK 0x000001ff
	77	#define CG14_VMCR1_VCONFIG_SHIFT 9
	78	#define CG14_VMCR1_VCONFIG_MASK 0x00000e00
	79	#define CG14_VMCR2_REFRESH_SHIFT 0
	80	#define CG14_VMCR2_REFRESH_MASK 0x00000001
	81	#define CG14_VMCR2_TESTROWCNT_SHIFT 1
	82	#define CG14_VMCR2_TESTROWCNT_MASK 0x00000002
	83	#define CG14_VMCR2_FBCONFIG_SHIFT 2
	84	#define CG14_VMCR2_FBCONFIG_MASK 0x0000000c
	85	#define CG14_VCR_REFRESHREQ_SHIFT 0
	86	#define CG14_VCR_REFRESHREQ_MASK 0x000003ff
	87	#define CG14_VCR1_REFRESHENA_SHIFT 10
	88	#define CG14_VCR1_REFRESHENA_MASK 0x00000400
	89	#define CG14_VCA_CAD_SHIFT 0
	90	#define CG14_VCA_CAD_MASK 0x000003ff
	91	#define CG14_VCA_VERS_SHIFT 10
	92	#define CG14_VCA_VERS_MASK 0x00000c00
	93	#define CG14_VCA_RAMSPEED_SHIFT 12
	94	#define CG14_VCA_RAMSPEED_MASK 0x00001000
	95	#define CG14_VCA_8MB_SHIFT 13
	96	#define CG14_VCA_8MB_MASK 0x00002000
	97
	98	#define CG14_MCR_PIXMODE_8 0
	99	#define CG14_MCR_PIXMODE_16 2
	100	#define CG14_MCR_PIXMODE_32 3
	101
	102	struct cg14_regs{
50312ce9 DM	103	u8 mcr; /* Master Control Reg */
	104	u8 ppr; /* Packed Pixel Reg */
	105	u8 tms[2]; /* Test Mode Status Regs */
	106	u8 msr; /* Master Status Reg */
	107	u8 fsr; /* Fault Status Reg */
	108	u8 rev; /* Revision & Impl */
	109	u8 ccr; /* Clock Control Reg */
	110	u32 tmr; /* Test Mode Read Back */
	111	u8 mod; /* Monitor Operation Data Reg */
	112	u8 acr; /* Aux Control */
1da177e4	113	u8 xxx0[6];
50312ce9 DM	114	u16 hct; /* Hor Counter */
	115	u16 vct; /* Vert Counter */
	116	u16 hbs; /* Hor Blank Start */
	117	u16 hbc; /* Hor Blank Clear */
	118	u16 hss; /* Hor Sync Start */
	119	u16 hsc; /* Hor Sync Clear */
	120	u16 csc; /* Composite Sync Clear */
	121	u16 vbs; /* Vert Blank Start */
	122	u16 vbc; /* Vert Blank Clear */
	123	u16 vss; /* Vert Sync Start */
	124	u16 vsc; /* Vert Sync Clear */
	125	u16 xcs;
	126	u16 xcc;
	127	u16 fsa; /* Fault Status Address */
	128	u16 adr; /* Address Registers */
1da177e4	129	u8 xxx1[0xce];
50312ce9 DM	130	u8 pcg[0x100]; /* Pixel Clock Generator */
	131	u32 vbr; /* Frame Base Row */
	132	u32 vmcr; /* VBC Master Control */
	133	u32 vcr; /* VBC refresh */
	134	u32 vca; /* VBC Config */
1da177e4 LT	135	};
	136
	137	#define CG14_CCR_ENABLE 0x04
	138	#define CG14_CCR_SELECT 0x02 /* HW/Full screen */
	139
	140	struct cg14_cursor {
50312ce9 DM	141	u32 cpl0[32]; /* Enable plane 0 */
	142	u32 cpl1[32]; /* Color selection plane */
	143	u8 ccr; /* Cursor Control Reg */
1da177e4	144	u8 xxx0[3];
50312ce9 DM	145	u16 cursx; /* Cursor x,y position */
	146	u16 cursy; /* Cursor x,y position */
	147	u32 color0;
	148	u32 color1;
1da177e4	149	u32 xxx1[0x1bc];
50312ce9 DM	150	u32 cpl0i[32]; /* Enable plane 0 autoinc */
50312ce9 DM	151	u32 cpl1i[32]; /* Color selection autoinc */
1da177e4 LT	152	};
	153
	154	struct cg14_dac {
50312ce9	155	u8 addr; /* Address Register */
1da177e4	156	u8 xxx0[255];
50312ce9	157	u8 glut; /* Gamma table */
1da177e4	158	u8 xxx1[255];
50312ce9	159	u8 select; /* Register Select */
1da177e4	160	u8 xxx2[255];
50312ce9	161	u8 mode; /* Mode Register */
1da177e4 LT	162	};
	163
	164	struct cg14_xlut{
50312ce9 DM	165	u8 x_xlut [256];
50312ce9 DM	166	u8 x_xlutd [256];
1da177e4	167	u8 xxx0[0x600];
50312ce9 DM	168	u8 x_xlut_inc [256];
50312ce9 DM	169	u8 x_xlutd_inc [256];
1da177e4 LT	170	};
	171
	172	/* Color look up table (clut) */
	173	/* Each one of these arrays hold the color lookup table (for 256
	174	* colors) for each MDI page (I assume then there should be 4 MDI
	175	* pages, I still wonder what they are. I have seen NeXTStep split
	176	* the screen in four parts, while operating in 24 bits mode. Each
	177	* integer holds 4 values: alpha value (transparency channel, thanks
	178	* go to John Stone (johns@umr.edu) from OpenBSD), red, green and blue
	179	*
	180	* I currently use the clut instead of the Xlut
	181	*/
	182	struct cg14_clut {
	183	u32 c_clut [256];
	184	u32 c_clutd [256]; /* i wonder what the 'd' is for */
	185	u32 c_clut_inc [256];
	186	u32 c_clutd_inc [256];
	187	};
	188
	189	#define CG14_MMAP_ENTRIES 16
	190
	191	struct cg14_par {
	192	spinlock_t lock;
	193	struct cg14_regs __iomem *regs;
	194	struct cg14_clut __iomem *clut;
	195	struct cg14_cursor __iomem *cursor;
	196
	197	u32 flags;
	198	#define CG14_FLAG_BLANKED 0x00000001
	199
	200	unsigned long physbase;
	201	unsigned long iospace;
	202	unsigned long fbsize;
	203
	204	struct sbus_mmap_map mmap_map[CG14_MMAP_ENTRIES];
	205
	206	int mode;
	207	int ramsize;
1da177e4 LT	208	};
	209
	210	static void __cg14_reset(struct cg14_par *par)
	211	{
	212	struct cg14_regs __iomem *regs = par->regs;
	213	u8 val;
	214
	215	val = sbus_readb(&regs->mcr);
	216	val &= ~(CG14_MCR_PIXMODE_MASK);
	217	sbus_writeb(val, &regs->mcr);
	218	}
	219
	220	static int cg14_pan_display(struct fb_var_screeninfo var, struct fb_info info)
	221	{
	222	struct cg14_par par = (struct cg14_par ) info->par;
	223	unsigned long flags;
	224
	225	/* We just use this to catch switches out of
	226	* graphics mode.
	227	*/
	228	spin_lock_irqsave(&par->lock, flags);
	229	__cg14_reset(par);
	230	spin_unlock_irqrestore(&par->lock, flags);
	231
	232	if (var->xoffset \|\| var->yoffset \|\| var->vmode)
	233	return -EINVAL;
	234	return 0;
	235	}
	236
	237	/**
	238	* cg14_setcolreg - Optional function. Sets a color register.
	239	* @regno: boolean, 0 copy local, 1 get_user() function
	240	* @red: frame buffer colormap structure
	241	* @green: The green value which can be up to 16 bits wide
	242	* @blue: The blue value which can be up to 16 bits wide.
	243	* @transp: If supported the alpha value which can be up to 16 bits wide.
	244	* @info: frame buffer info structure
	245	*/
	246	static int cg14_setcolreg(unsigned regno,
	247	unsigned red, unsigned green, unsigned blue,
	248	unsigned transp, struct fb_info *info)
	249	{
	250	struct cg14_par par = (struct cg14_par ) info->par;
	251	struct cg14_clut __iomem *clut = par->clut;
	252	unsigned long flags;
	253	u32 val;
	254
	255	if (regno >= 256)
	256	return 1;
	257
	258	red >>= 8;
	259	green >>= 8;
	260	blue >>= 8;
	261	val = (red \| (green << 8) \| (blue << 16));
	262
	263	spin_lock_irqsave(&par->lock, flags);
	264	sbus_writel(val, &clut->c_clut[regno]);
	265	spin_unlock_irqrestore(&par->lock, flags);
	266
	267	return 0;
	268	}
	269
216d526c	270	static int cg14_mmap(struct fb_info info, struct vm_area_struct vma)
1da177e4 LT	271	{
	272	struct cg14_par par = (struct cg14_par ) info->par;
	273
	274	return sbusfb_mmap_helper(par->mmap_map,
	275	par->physbase, par->fbsize,
	276	par->iospace, vma);
	277	}
	278
67a6680d	279	static int cg14_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
1da177e4 LT	280	{
	281	struct cg14_par par = (struct cg14_par ) info->par;
	282	struct cg14_regs __iomem *regs = par->regs;
	283	struct mdi_cfginfo kmdi, __user *mdii;
	284	unsigned long flags;
	285	int cur_mode, mode, ret = 0;
	286
	287	switch (cmd) {
	288	case MDI_RESET:
	289	spin_lock_irqsave(&par->lock, flags);
	290	__cg14_reset(par);
	291	spin_unlock_irqrestore(&par->lock, flags);
	292	break;
	293
	294	case MDI_GET_CFGINFO:
	295	memset(&kmdi, 0, sizeof(kmdi));
	296
	297	spin_lock_irqsave(&par->lock, flags);
	298	kmdi.mdi_type = FBTYPE_MDICOLOR;
	299	kmdi.mdi_height = info->var.yres;
	300	kmdi.mdi_width = info->var.xres;
	301	kmdi.mdi_mode = par->mode;
	302	kmdi.mdi_pixfreq = 72; /* FIXME */
	303	kmdi.mdi_size = par->ramsize;
	304	spin_unlock_irqrestore(&par->lock, flags);
	305
	306	mdii = (struct mdi_cfginfo __user *) arg;
	307	if (copy_to_user(mdii, &kmdi, sizeof(kmdi)))
	308	ret = -EFAULT;
	309	break;
	310
	311	case MDI_SET_PIXELMODE:
	312	if (get_user(mode, (int __user *) arg)) {
	313	ret = -EFAULT;
	314	break;
	315	}
	316
	317	spin_lock_irqsave(&par->lock, flags);
	318	cur_mode = sbus_readb(&regs->mcr);
	319	cur_mode &= ~CG14_MCR_PIXMODE_MASK;
	320	switch(mode) {
	321	case MDI_32_PIX:
	322	cur_mode \|= (CG14_MCR_PIXMODE_32 <<
	323	CG14_MCR_PIXMODE_SHIFT);
	324	break;
	325
	326	case MDI_16_PIX:
	327	cur_mode \|= (CG14_MCR_PIXMODE_16 <<
	328	CG14_MCR_PIXMODE_SHIFT);
	329	break;
	330
	331	case MDI_8_PIX:
	332	break;
	333
	334	default:
	335	ret = -ENOSYS;
	336	break;
	337	};
	338	if (!ret) {
	339	sbus_writeb(cur_mode, &regs->mcr);
	340	par->mode = mode;
	341	}
	342	spin_unlock_irqrestore(&par->lock, flags);
	343	break;
344
345	default:
346	ret = sbusfb_ioctl_helper(cmd, arg, info,
347	FBTYPE_MDICOLOR, 8, par->fbsize);
348	break;
349	};
350
351	return ret;
352	}
353
354	/*
355	* Initialisation
356	*/
357
8fdab476 RR	358	static void __devinit cg14_init_fix(struct fb_info *info, int linebytes,
8fdab476 RR	359	struct device_node *dp)
1da177e4	360	{
50312ce9	361	const char *name = dp->name;
1da177e4 LT	362
	363	strlcpy(info->fix.id, name, sizeof(info->fix.id));
	364
	365	info->fix.type = FB_TYPE_PACKED_PIXELS;
	366	info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
	367
	368	info->fix.line_length = linebytes;
	369
	370	info->fix.accel = FB_ACCEL_SUN_CG14;
	371	}
	372
8fdab476	373	static struct sbus_mmap_map __cg14_mmap_map[CG14_MMAP_ENTRIES] __devinitdata = {
1da177e4 LT	374	{
	375	.voff = CG14_REGS,
	376	.poff = 0x80000000,
	377	.size = 0x1000
	378	},
	379	{
	380	.voff = CG14_XLUT,
	381	.poff = 0x80003000,
	382	.size = 0x1000
	383	},
	384	{
	385	.voff = CG14_CLUT1,
	386	.poff = 0x80004000,
	387	.size = 0x1000
	388	},
	389	{
	390	.voff = CG14_CLUT2,
	391	.poff = 0x80005000,
	392	.size = 0x1000
	393	},
	394	{
	395	.voff = CG14_CLUT3,
	396	.poff = 0x80006000,
	397	.size = 0x1000
	398	},
	399	{
	400	.voff = CG3_MMAP_OFFSET - 0x7000,
	401	.poff = 0x80000000,
	402	.size = 0x7000
	403	},
	404	{
	405	.voff = CG3_MMAP_OFFSET,
	406	.poff = 0x00000000,
	407	.size = SBUS_MMAP_FBSIZE(1)
	408	},
	409	{
	410	.voff = MDI_CURSOR_MAP,
	411	.poff = 0x80001000,
	412	.size = 0x1000
	413	},
	414	{
	415	.voff = MDI_CHUNKY_BGR_MAP,
	416	.poff = 0x01000000,
	417	.size = 0x400000
	418	},
	419	{
	420	.voff = MDI_PLANAR_X16_MAP,
	421	.poff = 0x02000000,
	422	.size = 0x200000
	423	},
	424	{
	425	.voff = MDI_PLANAR_C16_MAP,
	426	.poff = 0x02800000,
	427	.size = 0x200000
	428	},
	429	{
	430	.voff = MDI_PLANAR_X32_MAP,
	431	.poff = 0x03000000,
	432	.size = 0x100000
	433	},
	434	{
	435	.voff = MDI_PLANAR_B32_MAP,
	436	.poff = 0x03400000,
	437	.size = 0x100000
438	},
439	{
440	.voff = MDI_PLANAR_G32_MAP,
441	.poff = 0x03800000,
442	.size = 0x100000
443	},
444	{
445	.voff = MDI_PLANAR_R32_MAP,
446	.poff = 0x03c00000,
447	.size = 0x100000
448	},
449	{ .size = 0 }
450	};
451
c7f439b9 DM	452	static void cg14_unmap_regs(struct of_device op, struct fb_info info,
c7f439b9 DM	453	struct cg14_par *par)
1da177e4	454	{
c7f439b9	455	if (par->regs)
e3a411a3	456	of_iounmap(&op->resource[0],
c7f439b9 DM	457	par->regs, sizeof(struct cg14_regs));
c7f439b9 DM	458	if (par->clut)
e3a411a3	459	of_iounmap(&op->resource[0],
c7f439b9 DM	460	par->clut, sizeof(struct cg14_clut));
c7f439b9 DM	461	if (par->cursor)
e3a411a3	462	of_iounmap(&op->resource[0],
c7f439b9 DM	463	par->cursor, sizeof(struct cg14_cursor));
c7f439b9 DM	464	if (info->screen_base)
e3a411a3	465	of_iounmap(&op->resource[1],
c7f439b9	466	info->screen_base, par->fbsize);
50312ce9	467	}
1da177e4	468
c7f439b9	469	static int __devinit cg14_probe(struct of_device op, const struct of_device_id match)
50312ce9 DM	470	{
50312ce9 DM	471	struct device_node *dp = op->node;
c7f439b9 DM	472	struct fb_info *info;
c7f439b9 DM	473	struct cg14_par *par;
50312ce9	474	int is_8mb, linebytes, i, err;
1da177e4	475
c7f439b9 DM	476	info = framebuffer_alloc(sizeof(struct cg14_par), &op->dev);
	477
	478	err = -ENOMEM;
	479	if (!info)
	480	goto out_err;
	481	par = info->par;
1da177e4	482
c7f439b9	483	spin_lock_init(&par->lock);
1da177e4	484
c7f439b9 DM	485	sbusfb_fill_var(&info->var, dp->node, 8);
	486	info->var.red.length = 8;
	487	info->var.green.length = 8;
	488	info->var.blue.length = 8;
1da177e4	489
50312ce9	490	linebytes = of_getintprop_default(dp, "linebytes",
c7f439b9 DM	491	info->var.xres);
c7f439b9 DM	492	par->fbsize = PAGE_ALIGN(linebytes * info->var.yres);
1da177e4	493
50312ce9 DM	494	if (!strcmp(dp->parent->name, "sbus") \|\|
50312ce9 DM	495	!strcmp(dp->parent->name, "sbi")) {
c7f439b9 DM	496	par->physbase = op->resource[0].start;
c7f439b9 DM	497	par->iospace = op->resource[0].flags & IORESOURCE_BITS;
1da177e4	498	} else {
c7f439b9 DM	499	par->physbase = op->resource[1].start;
c7f439b9 DM	500	par->iospace = op->resource[0].flags & IORESOURCE_BITS;
1da177e4 LT	501	}
1da177e4 LT	502
c7f439b9 DM	503	par->regs = of_ioremap(&op->resource[0], 0,
	504	sizeof(struct cg14_regs), "cg14 regs");
	505	par->clut = of_ioremap(&op->resource[0], CG14_CLUT1,
	506	sizeof(struct cg14_clut), "cg14 clut");
	507	par->cursor = of_ioremap(&op->resource[0], CG14_CURSORREGS,
	508	sizeof(struct cg14_cursor), "cg14 cursor");
1da177e4	509
c7f439b9 DM	510	info->screen_base = of_ioremap(&op->resource[1], 0,
c7f439b9 DM	511	par->fbsize, "cg14 ram");
1da177e4	512
c7f439b9 DM	513	if (!par->regs \|\| !par->clut \|\| !par->cursor \|\| !info->screen_base)
c7f439b9 DM	514	goto out_unmap_regs;
50312ce9 DM	515
	516	is_8mb = (((op->resource[1].end - op->resource[1].start) + 1) ==
	517	(8 * 1024 * 1024));
	518
c7f439b9	519	BUILD_BUG_ON(sizeof(par->mmap_map) != sizeof(__cg14_mmap_map));
1da177e4	520
c7f439b9	521	memcpy(&par->mmap_map, &__cg14_mmap_map, sizeof(par->mmap_map));
50312ce9	522
1da177e4	523	for (i = 0; i < CG14_MMAP_ENTRIES; i++) {
c7f439b9	524	struct sbus_mmap_map *map = &par->mmap_map[i];
1da177e4 LT	525
	526	if (!map->size)
	527	break;
	528	if (map->poff & 0x80000000)
50312ce9 DM	529	map->poff = (map->poff & 0x7fffffff) +
	530	(op->resource[0].start -
	531	op->resource[1].start);
1da177e4 LT	532	if (is_8mb &&
	533	map->size >= 0x100000 &&
	534	map->size <= 0x400000)
	535	map->size *= 2;
	536	}
	537
c7f439b9 DM	538	par->mode = MDI_8_PIX;
c7f439b9 DM	539	par->ramsize = (is_8mb ? 0x800000 : 0x400000);
1da177e4	540
c7f439b9 DM	541	info->flags = FBINFO_DEFAULT \| FBINFO_HWACCEL_YPAN;
c7f439b9 DM	542	info->fbops = &cg14_ops;
1da177e4	543
c7f439b9	544	__cg14_reset(par);
1da177e4	545
c7f439b9 DM	546	if (fb_alloc_cmap(&info->cmap, 256, 0))
c7f439b9 DM	547	goto out_unmap_regs;
1da177e4	548
c7f439b9	549	fb_set_cmap(&info->cmap, info);
1da177e4	550
c7f439b9 DM	551	cg14_init_fix(info, linebytes, dp);
	552
	553	err = register_framebuffer(info);
	554	if (err < 0)
	555	goto out_dealloc_cmap;
1da177e4	556
c7f439b9	557	dev_set_drvdata(&op->dev, info);
1da177e4	558
50312ce9 DM	559	printk("%s: cgfourteen at %lx:%lx, %dMB\n",
50312ce9 DM	560	dp->full_name,
c7f439b9 DM	561	par->iospace, par->physbase,
c7f439b9 DM	562	par->ramsize >> 20);
1da177e4	563
50312ce9	564	return 0;
1da177e4	565
c7f439b9 DM	566	out_dealloc_cmap:
	567	fb_dealloc_cmap(&info->cmap);
	568
	569	out_unmap_regs:
	570	cg14_unmap_regs(op, info, par);
1da177e4	571
c7f439b9 DM	572	out_err:
c7f439b9 DM	573	return err;
50312ce9	574	}
1da177e4	575
e3a411a3	576	static int __devexit cg14_remove(struct of_device *op)
50312ce9	577	{
c7f439b9 DM	578	struct fb_info *info = dev_get_drvdata(&op->dev);
c7f439b9 DM	579	struct cg14_par *par = info->par;
50312ce9	580
c7f439b9 DM	581	unregister_framebuffer(info);
c7f439b9 DM	582	fb_dealloc_cmap(&info->cmap);
50312ce9	583
c7f439b9	584	cg14_unmap_regs(op, info, par);
50312ce9	585
c7f439b9	586	framebuffer_release(info);
50312ce9	587
e3a411a3	588	dev_set_drvdata(&op->dev, NULL);
1da177e4 LT	589
	590	return 0;
	591	}
	592
50312ce9 DM	593	static struct of_device_id cg14_match[] = {
	594	{
	595	.name = "cgfourteen",
	596	},
	597	{},
	598	};
	599	MODULE_DEVICE_TABLE(of, cg14_match);
1da177e4	600
50312ce9 DM	601	static struct of_platform_driver cg14_driver = {
	602	.name = "cg14",
	603	.match_table = cg14_match,
	604	.probe = cg14_probe,
	605	.remove = __devexit_p(cg14_remove),
	606	};
1da177e4	607
50312ce9 DM	608	int __init cg14_init(void)
	609	{
	610	if (fb_get_options("cg14fb", NULL))
	611	return -ENODEV;
	612
	613	return of_register_driver(&cg14_driver, &of_bus_type);
1da177e4 LT	614	}
1da177e4 LT	615
50312ce9	616	void __exit cg14_exit(void)
1da177e4	617	{
50312ce9	618	of_unregister_driver(&cg14_driver);
1da177e4 LT	619	}
	620
	621	module_init(cg14_init);
1da177e4	622	module_exit(cg14_exit);
1da177e4 LT	623
1da177e4 LT	624	MODULE_DESCRIPTION("framebuffer driver for CGfourteen chipsets");
50312ce9 DM	625	MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
50312ce9 DM	626	MODULE_VERSION("2.0");
1da177e4	627	MODULE_LICENSE("GPL");