[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / video / arcfb.c

/*
 * linux/drivers/video/arcfb.c -- FB driver for Arc monochrome LCD board
 *
 * Copyright (C) 2005, Jaya Kumar <jayalk@intworks.biz>
 * http://www.intworks.biz/arclcd
 *
 * 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.
 *
 * Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven.
 *
 * This driver was written to be used with the Arc LCD board. Arc uses a
 * set of KS108 chips that control individual 64x64 LCD matrices. The board
 * can be paneled in a variety of setups such as 2x1=128x64, 4x4=256x256 and
 * so on. The interface between the board and the host is TTL based GPIO. The
 * GPIO requirements are 8 writable data lines and 4+n lines for control. On a
 * GPIO-less system, the board can be tested by connecting the respective sigs
 * up to a parallel port connector. The driver requires the IO addresses for
 * data and control GPIO at load time. It is unable to probe for the
 * existence of the LCD so it must be told at load time whether it should
 * be enabled or not.
 *
 * Todo:
 * - testing with 4x4
 * - testing with interrupt hw
 *
 * General notes:
 * - User must set tuhold. It's in microseconds. According to the 108 spec,
 *   the hold time is supposed to be at least 1 microsecond.
 * - User must set num_cols=x num_rows=y, eg: x=2 means 128
 * - User must set arcfb_enable=1 to enable it
 * - User must set dio_addr=0xIOADDR cio_addr=0xIOADDR
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/arcfb.h>
#include <linux/platform_device.h>

#include <asm/uaccess.h>

#define floor8(a) (a&(~0x07))
#define floorXres(a,xres) (a&(~(xres - 1)))
#define iceil8(a) (((int)((a+7)/8))*8)
#define ceil64(a) (a|0x3F)
#define ceilXres(a,xres) (a|(xres - 1))

/* ks108 chipset specific defines and code */

#define KS_SET_DPY_START_LINE 	0xC0
#define KS_SET_PAGE_NUM 	0xB8
#define KS_SET_X 		0x40
#define KS_CEHI 		0x01
#define KS_CELO 		0x00
#define KS_SEL_CMD 		0x08
#define KS_SEL_DATA 		0x00
#define KS_DPY_ON 		0x3F
#define KS_DPY_OFF 		0x3E
#define KS_INTACK 		0x40
#define KS_CLRINT		0x02

struct arcfb_par {
	unsigned long dio_addr;
	unsigned long cio_addr;
	unsigned long c2io_addr;
	atomic_t ref_count;
	unsigned char cslut[9];
	struct fb_info *info;
	unsigned int irq;
	spinlock_t lock;
};

static struct fb_fix_screeninfo arcfb_fix __initdata = {
	.id =		"arcfb",
	.type =		FB_TYPE_PACKED_PIXELS,
	.visual =	FB_VISUAL_MONO01,
	.xpanstep =	0,
	.ypanstep =	1,
	.ywrapstep =	0,
	.accel =	FB_ACCEL_NONE,
};

static struct fb_var_screeninfo arcfb_var __initdata = {
	.xres		= 128,
	.yres		= 64,
	.xres_virtual	= 128,
	.yres_virtual	= 64,
	.bits_per_pixel	= 1,
	.nonstd		= 1,
};

static unsigned long num_cols;
static unsigned long num_rows;
static unsigned long dio_addr;
static unsigned long cio_addr;
static unsigned long c2io_addr;
static unsigned long splashval;
static unsigned long tuhold;
static unsigned int nosplash;
static unsigned int arcfb_enable;
static unsigned int irq;

static DECLARE_WAIT_QUEUE_HEAD(arcfb_waitq);

static void ks108_writeb_ctl(struct arcfb_par *par,
				unsigned int chipindex, unsigned char value)
{
	unsigned char chipselval = par->cslut[chipindex];

	outb(chipselval|KS_CEHI|KS_SEL_CMD, par->cio_addr);
	outb(value, par->dio_addr);
	udelay(tuhold);
	outb(chipselval|KS_CELO|KS_SEL_CMD, par->cio_addr);
}

static void ks108_writeb_mainctl(struct arcfb_par *par, unsigned char value)
{

	outb(value, par->cio_addr);
	udelay(tuhold);
}

static unsigned char ks108_readb_ctl2(struct arcfb_par *par)
{
	return inb(par->c2io_addr);
}

static void ks108_writeb_data(struct arcfb_par *par,
				unsigned int chipindex, unsigned char value)
{
	unsigned char chipselval = par->cslut[chipindex];

	outb(chipselval|KS_CEHI|KS_SEL_DATA, par->cio_addr);
	outb(value, par->dio_addr);
	udelay(tuhold);
	outb(chipselval|KS_CELO|KS_SEL_DATA, par->cio_addr);
}

static void ks108_set_start_line(struct arcfb_par *par,
				unsigned int chipindex, unsigned char y)
{
	ks108_writeb_ctl(par, chipindex, KS_SET_DPY_START_LINE|y);
}

static void ks108_set_yaddr(struct arcfb_par *par,
				unsigned int chipindex, unsigned char y)
{
	ks108_writeb_ctl(par, chipindex, KS_SET_PAGE_NUM|y);
}

static void ks108_set_xaddr(struct arcfb_par *par,
				unsigned int chipindex, unsigned char x)
{
	ks108_writeb_ctl(par, chipindex, KS_SET_X|x);
}

static void ks108_clear_lcd(struct arcfb_par *par, unsigned int chipindex)
{
	int i,j;

	for (i = 0; i <= 8; i++) {
		ks108_set_yaddr(par, chipindex, i);
		ks108_set_xaddr(par, chipindex, 0);
		for (j = 0; j < 64; j++) {
			ks108_writeb_data(par, chipindex,
				(unsigned char) splashval);
		}
	}
}

/* main arcfb functions */

static int arcfb_open(struct fb_info *info, int user)
{
	struct arcfb_par *par = info->par;

	atomic_inc(&par->ref_count);
	return 0;
}

static int arcfb_release(struct fb_info *info, int user)
{
	struct arcfb_par *par = info->par;
	int count = atomic_read(&par->ref_count);

	if (!count)
		return -EINVAL;
	atomic_dec(&par->ref_count);
	return 0;
}

static int arcfb_pan_display(struct fb_var_screeninfo *var,
				struct fb_info *info)
{
	int i;
	struct arcfb_par *par = info->par;

	if ((var->vmode & FB_VMODE_YWRAP) && (var->yoffset < 64)
		&& (info->var.yres <= 64)) {
		for (i = 0; i < num_cols; i++) {
			ks108_set_start_line(par, i, var->yoffset);
		}
		info->var.yoffset = var->yoffset;
		return 0;
	}

	return -EINVAL;
}

static irqreturn_t arcfb_interrupt(int vec, void *dev_instance)
{
	struct fb_info *info = dev_instance;
	unsigned char ctl2status;
	struct arcfb_par *par = info->par;

	ctl2status = ks108_readb_ctl2(par);

	if (!(ctl2status & KS_INTACK)) /* not arc generated interrupt */
		return IRQ_NONE;

	ks108_writeb_mainctl(par, KS_CLRINT);

	spin_lock(&par->lock);
        if (waitqueue_active(&arcfb_waitq)) {
                wake_up(&arcfb_waitq);
        }
	spin_unlock(&par->lock);

	return IRQ_HANDLED;
}

/*
 * here we handle a specific page on the lcd. the complexity comes from
 * the fact that the fb is laidout in 8xX vertical columns. we extract
 * each write of 8 vertical pixels. then we shift out as we move along
 * X. That's what rightshift does. bitmask selects the desired input bit.
 */
static void arcfb_lcd_update_page(struct arcfb_par *par, unsigned int upper,
		unsigned int left, unsigned int right, unsigned int distance)
{
	unsigned char *src;
	unsigned int xindex, yindex, chipindex, linesize;
	int i;
	unsigned char val;
	unsigned char bitmask, rightshift;

	xindex = left >> 6;
	yindex = upper >> 6;
	chipindex = (xindex + (yindex*num_cols));

	ks108_set_yaddr(par, chipindex, upper/8);

	linesize = par->info->var.xres/8;
	src = (unsigned char __force *) par->info->screen_base + (left/8) +
		(upper * linesize);
	ks108_set_xaddr(par, chipindex, left);

	bitmask=1;
	rightshift=0;
	while (left <= right) {
		val = 0;
		for (i = 0; i < 8; i++) {
			if ( i > rightshift) {
				val |= (*(src + (i*linesize)) & bitmask)
						<< (i - rightshift);
			} else {
				val |= (*(src + (i*linesize)) & bitmask)
						 >> (rightshift - i);
			}
		}
		ks108_writeb_data(par, chipindex, val);
		left++;
		if (bitmask == 0x80) {
			bitmask = 1;
			src++;
			rightshift=0;
		} else {
			bitmask <<= 1;
			rightshift++;
		}
	}
}

/*
 * here we handle the entire vertical page of the update. we write across
 * lcd chips. update_page uses the upper/left values to decide which
 * chip to select for the right. upper is needed for setting the page
 * desired for the write.
 */
static void arcfb_lcd_update_vert(struct arcfb_par *par, unsigned int top,
		unsigned int bottom, unsigned int left, unsigned int right)
{
	unsigned int distance, upper, lower;

	distance = (bottom - top) + 1;
	upper = top;
	lower = top + 7;

	while (distance > 0) {
		distance -= 8;
		arcfb_lcd_update_page(par, upper, left, right, 8);
		upper = lower + 1;
		lower = upper + 7;
	}
}

/*
 * here we handle horizontal blocks for the update. update_vert will
 * handle spaning multiple pages. we break out each horizontal
 * block in to individual blocks no taller than 64 pixels.
 */
static void arcfb_lcd_update_horiz(struct arcfb_par *par, unsigned int left,
			unsigned int right, unsigned int top, unsigned int h)
{
	unsigned int distance, upper, lower;

	distance = h;
	upper = floor8(top);
	lower = min(upper + distance - 1, ceil64(upper));

	while (distance > 0) {
		distance -= ((lower - upper) + 1 );
		arcfb_lcd_update_vert(par, upper, lower, left, right);
		upper = lower + 1;
		lower = min(upper + distance - 1, ceil64(upper));
	}
}

/*
 * here we start the process of spliting out the fb update into
 * individual blocks of pixels. we end up spliting into 64x64 blocks
 * and finally down to 64x8 pages.
 */
static void arcfb_lcd_update(struct arcfb_par *par, unsigned int dx,
			unsigned int dy, unsigned int w, unsigned int h)
{
	unsigned int left, right, distance, y;

	/* align the request first */
	y = floor8(dy);
	h += dy - y;
	h = iceil8(h);

	distance = w;
	left = dx;
	right = min(left + w - 1, ceil64(left));

	while (distance > 0) {
		arcfb_lcd_update_horiz(par, left, right, y, h);
		distance -= ((right - left) + 1);
		left = right + 1;
		right = min(left + distance - 1, ceil64(left));
	}
}

static void arcfb_fillrect(struct fb_info *info,
			   const struct fb_fillrect *rect)
{
	struct arcfb_par *par = info->par;

	cfb_fillrect(info, rect);

	/* update the physical lcd */
	arcfb_lcd_update(par, rect->dx, rect->dy, rect->width, rect->height);
}

static void arcfb_copyarea(struct fb_info *info,
			   const struct fb_copyarea *area)
{
	struct arcfb_par *par = info->par;

	cfb_copyarea(info, area);

	/* update the physical lcd */
	arcfb_lcd_update(par, area->dx, area->dy, area->width, area->height);
}

static void arcfb_imageblit(struct fb_info *info, const struct fb_image *image)
{
	struct arcfb_par *par = info->par;

	cfb_imageblit(info, image);

	/* update the physical lcd */
	arcfb_lcd_update(par, image->dx, image->dy, image->width,
				image->height);
}

static int arcfb_ioctl(struct fb_info *info,
			  unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	struct arcfb_par *par = info->par;
	unsigned long flags;

	switch (cmd) {
		case FBIO_WAITEVENT:
		{
			DEFINE_WAIT(wait);
			/* illegal to wait on arc if no irq will occur */
			if (!par->irq)
				return -EINVAL;

			/* wait until the Arc has generated an interrupt
			 * which will wake us up */
			spin_lock_irqsave(&par->lock, flags);
			prepare_to_wait(&arcfb_waitq, &wait,
					TASK_INTERRUPTIBLE);
			spin_unlock_irqrestore(&par->lock, flags);
			schedule();
			finish_wait(&arcfb_waitq, &wait);
		}
		case FBIO_GETCONTROL2:
		{
			unsigned char ctl2;

			ctl2 = ks108_readb_ctl2(info->par);
			if (copy_to_user(argp, &ctl2, sizeof(ctl2)))
				return -EFAULT;
			return 0;
		}
		default:
			return -EINVAL;
	}
}

/*
 * this is the access path from userspace. they can seek and write to
 * the fb. it's inefficient for them to do anything less than 64*8
 * writes since we update the lcd in each write() anyway.
 */
static ssize_t arcfb_write(struct file *file, const char __user *buf, size_t count,
				loff_t *ppos)
{
	/* modded from epson 1355 */

	struct inode *inode;
	int fbidx;
	struct fb_info *info;
	unsigned long p;
	int err=-EINVAL;
	unsigned int fbmemlength,x,y,w,h, bitppos, startpos, endpos, bitcount;
	struct arcfb_par *par;
	unsigned int xres;

	p = *ppos;
	inode = file->f_path.dentry->d_inode;
	fbidx = iminor(inode);
	info = registered_fb[fbidx];

	if (!info || !info->screen_base)
		return -ENODEV;

	par = info->par;
	xres = info->var.xres;
	fbmemlength = (xres * info->var.yres)/8;

	if (p > fbmemlength)
		return -ENOSPC;

	err = 0;
	if ((count + p) > fbmemlength) {
		count = fbmemlength - p;
		err = -ENOSPC;
	}

	if (count) {
		char *base_addr;

		base_addr = (char __force *)info->screen_base;
		count -= copy_from_user(base_addr + p, buf, count);
		*ppos += count;
		err = -EFAULT;
	}


	bitppos = p*8;
	startpos = floorXres(bitppos, xres);
	endpos = ceilXres((bitppos + (count*8)), xres);
	bitcount = endpos - startpos;

	x = startpos % xres;
	y = startpos / xres;
	w = xres;
	h = bitcount / xres;
	arcfb_lcd_update(par, x, y, w, h);

	if (count)
		return count;
	return err;
}

static struct fb_ops arcfb_ops = {
	.owner		= THIS_MODULE,
	.fb_open	= arcfb_open,
	.fb_write	= arcfb_write,
	.fb_release	= arcfb_release,
	.fb_pan_display	= arcfb_pan_display,
	.fb_fillrect	= arcfb_fillrect,
	.fb_copyarea	= arcfb_copyarea,
	.fb_imageblit	= arcfb_imageblit,
	.fb_ioctl 	= arcfb_ioctl,
};

static int __init arcfb_probe(struct platform_device *dev)
{
	struct fb_info *info;
	int retval = -ENOMEM;
	int videomemorysize;
	unsigned char *videomemory;
	struct arcfb_par *par;
	int i;

	videomemorysize = (((64*64)*num_cols)*num_rows)/8;

	/* We need a flat backing store for the Arc's
	   less-flat actual paged framebuffer */
	if (!(videomemory = vmalloc(videomemorysize)))
		return retval;

	memset(videomemory, 0, videomemorysize);

	info = framebuffer_alloc(sizeof(struct arcfb_par), &dev->dev);
	if (!info)
		goto err;

	info->screen_base = (char __iomem *)videomemory;
	info->fbops = &arcfb_ops;

	info->var = arcfb_var;
	info->fix = arcfb_fix;
	par = info->par;
	par->info = info;

	if (!dio_addr || !cio_addr || !c2io_addr) {
		printk(KERN_WARNING "no IO addresses supplied\n");
		goto err1;
	}
	par->dio_addr = dio_addr;
	par->cio_addr = cio_addr;
	par->c2io_addr = c2io_addr;
	par->cslut[0] = 0x00;
	par->cslut[1] = 0x06;
	info->flags = FBINFO_FLAG_DEFAULT;
	spin_lock_init(&par->lock);
	retval = register_framebuffer(info);
	if (retval < 0)
		goto err1;
	platform_set_drvdata(dev, info);
	if (irq) {
		par->irq = irq;
		if (request_irq(par->irq, &arcfb_interrupt, IRQF_SHARED,
				"arcfb", info)) {
			printk(KERN_INFO
				"arcfb: Failed req IRQ %d\n", par->irq);
			goto err1;
		}
	}
	printk(KERN_INFO
	       "fb%d: Arc frame buffer device, using %dK of video memory\n",
	       info->node, videomemorysize >> 10);

	/* this inits the lcd but doesn't clear dirty pixels */
	for (i = 0; i < num_cols * num_rows; i++) {
		ks108_writeb_ctl(par, i, KS_DPY_OFF);
		ks108_set_start_line(par, i, 0);
		ks108_set_yaddr(par, i, 0);
		ks108_set_xaddr(par, i, 0);
		ks108_writeb_ctl(par, i, KS_DPY_ON);
	}

	/* if we were told to splash the screen, we just clear it */
	if (!nosplash) {
		for (i = 0; i < num_cols * num_rows; i++) {
			printk(KERN_INFO "fb%d: splashing lcd %d\n",
				info->node, i);
			ks108_set_start_line(par, i, 0);
			ks108_clear_lcd(par, i);
		}
	}

	return 0;
err1:
	framebuffer_release(info);
err:
	vfree(videomemory);
	return retval;
}

static int arcfb_remove(struct platform_device *dev)
{
	struct fb_info *info = platform_get_drvdata(dev);

	if (info) {
		unregister_framebuffer(info);
		vfree((void __force *)info->screen_base);
		framebuffer_release(info);
	}
	return 0;
}

static struct platform_driver arcfb_driver = {
	.probe	= arcfb_probe,
	.remove = arcfb_remove,
	.driver	= {
		.name	= "arcfb",
	},
};

static struct platform_device *arcfb_device;

static int __init arcfb_init(void)
{
	int ret;

	if (!arcfb_enable)
		return -ENXIO;

	ret = platform_driver_register(&arcfb_driver);
	if (!ret) {
		arcfb_device = platform_device_alloc("arcfb", 0);
		if (arcfb_device) {
			ret = platform_device_add(arcfb_device);
		} else {
			ret = -ENOMEM;
		}
		if (ret) {
			platform_device_put(arcfb_device);
			platform_driver_unregister(&arcfb_driver);
		}
	}
	return ret;

}

static void __exit arcfb_exit(void)
{
	platform_device_unregister(arcfb_device);
	platform_driver_unregister(&arcfb_driver);
}

module_param(num_cols, ulong, 0);
MODULE_PARM_DESC(num_cols, "Num horiz panels, eg: 2 = 128 bit wide");
module_param(num_rows, ulong, 0);
MODULE_PARM_DESC(num_rows, "Num vert panels, eg: 1 = 64 bit high");
module_param(nosplash, uint, 0);
MODULE_PARM_DESC(nosplash, "Disable doing the splash screen");
module_param(arcfb_enable, uint, 0);
MODULE_PARM_DESC(arcfb_enable, "Enable communication with Arc board");
module_param(dio_addr, ulong, 0);
MODULE_PARM_DESC(dio_addr, "IO address for data, eg: 0x480");
module_param(cio_addr, ulong, 0);
MODULE_PARM_DESC(cio_addr, "IO address for control, eg: 0x400");
module_param(c2io_addr, ulong, 0);
MODULE_PARM_DESC(c2io_addr, "IO address for secondary control, eg: 0x408");
module_param(splashval, ulong, 0);
MODULE_PARM_DESC(splashval, "Splash pattern: 0xFF is black, 0x00 is green");
module_param(tuhold, ulong, 0);
MODULE_PARM_DESC(tuhold, "Time to hold between strobing data to Arc board");
module_param(irq, uint, 0);
MODULE_PARM_DESC(irq, "IRQ for the Arc board");

module_init(arcfb_init);
module_exit(arcfb_exit);

MODULE_DESCRIPTION("fbdev driver for Arc monochrome LCD board");
MODULE_AUTHOR("Jaya Kumar");
MODULE_LICENSE("GPL");
Commit	Line	Data
1154ea7d JK	1	/*
	2	* linux/drivers/video/arcfb.c -- FB driver for Arc monochrome LCD board
	3	*
	4	* Copyright (C) 2005, Jaya Kumar <jayalk@intworks.biz>
	5	* http://www.intworks.biz/arclcd
	6	*
	7	* This file is subject to the terms and conditions of the GNU General Public
	8	* License. See the file COPYING in the main directory of this archive for
	9	* more details.
	10	*
	11	* Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven.
	12	*
	13	* This driver was written to be used with the Arc LCD board. Arc uses a
	14	* set of KS108 chips that control individual 64x64 LCD matrices. The board
	15	* can be paneled in a variety of setups such as 2x1=128x64, 4x4=256x256 and
	16	* so on. The interface between the board and the host is TTL based GPIO. The
	17	* GPIO requirements are 8 writable data lines and 4+n lines for control. On a
	18	* GPIO-less system, the board can be tested by connecting the respective sigs
	19	* up to a parallel port connector. The driver requires the IO addresses for
	20	* data and control GPIO at load time. It is unable to probe for the
	21	* existence of the LCD so it must be told at load time whether it should
	22	* be enabled or not.
	23	*
	24	* Todo:
	25	* - testing with 4x4
	26	* - testing with interrupt hw
	27	*
	28	* General notes:
	29	* - User must set tuhold. It's in microseconds. According to the 108 spec,
	30	* the hold time is supposed to be at least 1 microsecond.
	31	* - User must set num_cols=x num_rows=y, eg: x=2 means 128
	32	* - User must set arcfb_enable=1 to enable it
	33	* - User must set dio_addr=0xIOADDR cio_addr=0xIOADDR
	34	*
	35	*/
	36
	37	#include <linux/module.h>
	38	#include <linux/kernel.h>
	39	#include <linux/errno.h>
	40	#include <linux/string.h>
	41	#include <linux/mm.h>
1154ea7d JK	42	#include <linux/slab.h>
	43	#include <linux/vmalloc.h>
	44	#include <linux/delay.h>
	45	#include <linux/interrupt.h>
	46	#include <linux/fb.h>
	47	#include <linux/init.h>
	48	#include <linux/arcfb.h>
d052d1be	49	#include <linux/platform_device.h>
1154ea7d JK	50
	51	#include <asm/uaccess.h>
	52
	53	#define floor8(a) (a&(~0x07))
	54	#define floorXres(a,xres) (a&(~(xres - 1)))
	55	#define iceil8(a) (((int)((a+7)/8))*8)
	56	#define ceil64(a) (a\|0x3F)
	57	#define ceilXres(a,xres) (a\|(xres - 1))
	58
	59	/* ks108 chipset specific defines and code */
	60
	61	#define KS_SET_DPY_START_LINE 0xC0
	62	#define KS_SET_PAGE_NUM 0xB8
	63	#define KS_SET_X 0x40
	64	#define KS_CEHI 0x01
	65	#define KS_CELO 0x00
	66	#define KS_SEL_CMD 0x08
	67	#define KS_SEL_DATA 0x00
	68	#define KS_DPY_ON 0x3F
	69	#define KS_DPY_OFF 0x3E
	70	#define KS_INTACK 0x40
	71	#define KS_CLRINT 0x02
	72
	73	struct arcfb_par {
	74	unsigned long dio_addr;
	75	unsigned long cio_addr;
	76	unsigned long c2io_addr;
	77	atomic_t ref_count;
	78	unsigned char cslut[9];
	79	struct fb_info *info;
	80	unsigned int irq;
	81	spinlock_t lock;
	82	};
	83
	84	static struct fb_fix_screeninfo arcfb_fix __initdata = {
	85	.id = "arcfb",
	86	.type = FB_TYPE_PACKED_PIXELS,
	87	.visual = FB_VISUAL_MONO01,
	88	.xpanstep = 0,
	89	.ypanstep = 1,
	90	.ywrapstep = 0,
	91	.accel = FB_ACCEL_NONE,
	92	};
	93
	94	static struct fb_var_screeninfo arcfb_var __initdata = {
	95	.xres = 128,
	96	.yres = 64,
	97	.xres_virtual = 128,
	98	.yres_virtual = 64,
	99	.bits_per_pixel = 1,
	100	.nonstd = 1,
	101	};
	102
	103	static unsigned long num_cols;
	104	static unsigned long num_rows;
	105	static unsigned long dio_addr;
	106	static unsigned long cio_addr;
	107	static unsigned long c2io_addr;
	108	static unsigned long splashval;
	109	static unsigned long tuhold;
	110	static unsigned int nosplash;
	111	static unsigned int arcfb_enable;
	112	static unsigned int irq;
	113
114	static DECLARE_WAIT_QUEUE_HEAD(arcfb_waitq);
115
116	static void ks108_writeb_ctl(struct arcfb_par *par,
117	unsigned int chipindex, unsigned char value)
118	{
119	unsigned char chipselval = par->cslut[chipindex];
120
121	outb(chipselval\|KS_CEHI\|KS_SEL_CMD, par->cio_addr);
122	outb(value, par->dio_addr);
123	udelay(tuhold);
124	outb(chipselval\|KS_CELO\|KS_SEL_CMD, par->cio_addr);
125	}
126
127	static void ks108_writeb_mainctl(struct arcfb_par *par, unsigned char value)
128	{
129
130	outb(value, par->cio_addr);
131	udelay(tuhold);
132	}
133
134	static unsigned char ks108_readb_ctl2(struct arcfb_par *par)
135	{
136	return inb(par->c2io_addr);
137	}
138
139	static void ks108_writeb_data(struct arcfb_par *par,
140	unsigned int chipindex, unsigned char value)
141	{
142	unsigned char chipselval = par->cslut[chipindex];
143
144	outb(chipselval\|KS_CEHI\|KS_SEL_DATA, par->cio_addr);
145	outb(value, par->dio_addr);
146	udelay(tuhold);
147	outb(chipselval\|KS_CELO\|KS_SEL_DATA, par->cio_addr);
148	}
149
150	static void ks108_set_start_line(struct arcfb_par *par,
151	unsigned int chipindex, unsigned char y)
152	{
153	ks108_writeb_ctl(par, chipindex, KS_SET_DPY_START_LINE\|y);
154	}
155
156	static void ks108_set_yaddr(struct arcfb_par *par,
157	unsigned int chipindex, unsigned char y)
158	{
159	ks108_writeb_ctl(par, chipindex, KS_SET_PAGE_NUM\|y);
160	}
161
162	static void ks108_set_xaddr(struct arcfb_par *par,
163	unsigned int chipindex, unsigned char x)
164	{
165	ks108_writeb_ctl(par, chipindex, KS_SET_X\|x);
166	}
167
168	static void ks108_clear_lcd(struct arcfb_par *par, unsigned int chipindex)
169	{
170	int i,j;
171
172	for (i = 0; i <= 8; i++) {
173	ks108_set_yaddr(par, chipindex, i);
174	ks108_set_xaddr(par, chipindex, 0);
175	for (j = 0; j < 64; j++) {
176	ks108_writeb_data(par, chipindex,
177	(unsigned char) splashval);
178	}
179	}
180	}
181
182	/* main arcfb functions */
183
184	static int arcfb_open(struct fb_info *info, int user)
185	{
186	struct arcfb_par *par = info->par;
187
188	atomic_inc(&par->ref_count);
189	return 0;
190	}
191
192	static int arcfb_release(struct fb_info *info, int user)
193	{
194	struct arcfb_par *par = info->par;
195	int count = atomic_read(&par->ref_count);
196
197	if (!count)
198	return -EINVAL;
199	atomic_dec(&par->ref_count);
200	return 0;
201	}
202
203	static int arcfb_pan_display(struct fb_var_screeninfo *var,
204	struct fb_info *info)
205	{
206	int i;
207	struct arcfb_par *par = info->par;
208
209	if ((var->vmode & FB_VMODE_YWRAP) && (var->yoffset < 64)
210	&& (info->var.yres <= 64)) {
211	for (i = 0; i < num_cols; i++) {
212	ks108_set_start_line(par, i, var->yoffset);
213	}
214	info->var.yoffset = var->yoffset;
215	return 0;
216	}
217
218	return -EINVAL;
219	}
220
7d12e780	221	static irqreturn_t arcfb_interrupt(int vec, void *dev_instance)
1154ea7d JK	222	{
	223	struct fb_info *info = dev_instance;
	224	unsigned char ctl2status;
	225	struct arcfb_par *par = info->par;
	226
	227	ctl2status = ks108_readb_ctl2(par);
	228
	229	if (!(ctl2status & KS_INTACK)) /* not arc generated interrupt */
	230	return IRQ_NONE;
	231
	232	ks108_writeb_mainctl(par, KS_CLRINT);
	233
	234	spin_lock(&par->lock);
	235	if (waitqueue_active(&arcfb_waitq)) {
	236	wake_up(&arcfb_waitq);
	237	}
	238	spin_unlock(&par->lock);
	239
	240	return IRQ_HANDLED;
	241	}
	242
	243	/*
	244	* here we handle a specific page on the lcd. the complexity comes from
	245	* the fact that the fb is laidout in 8xX vertical columns. we extract
	246	* each write of 8 vertical pixels. then we shift out as we move along
	247	* X. That's what rightshift does. bitmask selects the desired input bit.
	248	*/
	249	static void arcfb_lcd_update_page(struct arcfb_par *par, unsigned int upper,
	250	unsigned int left, unsigned int right, unsigned int distance)
	251	{
	252	unsigned char *src;
	253	unsigned int xindex, yindex, chipindex, linesize;
604cc999	254	int i;
1154ea7d JK	255	unsigned char val;
	256	unsigned char bitmask, rightshift;
	257
	258	xindex = left >> 6;
	259	yindex = upper >> 6;
	260	chipindex = (xindex + (yindex*num_cols));
	261
	262	ks108_set_yaddr(par, chipindex, upper/8);
	263
	264	linesize = par->info->var.xres/8;
d2e8d369 AD	265	src = (unsigned char __force *) par->info->screen_base + (left/8) +
d2e8d369 AD	266	(upper * linesize);
1154ea7d JK	267	ks108_set_xaddr(par, chipindex, left);
	268
	269	bitmask=1;
	270	rightshift=0;
	271	while (left <= right) {
	272	val = 0;
	273	for (i = 0; i < 8; i++) {
	274	if ( i > rightshift) {
	275	val \|= ((src + (ilinesize)) & bitmask)
	276	<< (i - rightshift);
	277	} else {
	278	val \|= ((src + (ilinesize)) & bitmask)
	279	>> (rightshift - i);
	280	}
	281	}
	282	ks108_writeb_data(par, chipindex, val);
	283	left++;
1154ea7d JK	284	if (bitmask == 0x80) {
	285	bitmask = 1;
	286	src++;
	287	rightshift=0;
	288	} else {
	289	bitmask <<= 1;
	290	rightshift++;
	291	}
	292	}
	293	}
	294
	295	/*
	296	* here we handle the entire vertical page of the update. we write across
	297	* lcd chips. update_page uses the upper/left values to decide which
	298	* chip to select for the right. upper is needed for setting the page
	299	* desired for the write.
	300	*/
	301	static void arcfb_lcd_update_vert(struct arcfb_par *par, unsigned int top,
	302	unsigned int bottom, unsigned int left, unsigned int right)
	303	{
	304	unsigned int distance, upper, lower;
	305
	306	distance = (bottom - top) + 1;
	307	upper = top;
	308	lower = top + 7;
	309
	310	while (distance > 0) {
	311	distance -= 8;
	312	arcfb_lcd_update_page(par, upper, left, right, 8);
	313	upper = lower + 1;
	314	lower = upper + 7;
	315	}
	316	}
	317
	318	/*
	319	* here we handle horizontal blocks for the update. update_vert will
	320	* handle spaning multiple pages. we break out each horizontal
	321	* block in to individual blocks no taller than 64 pixels.
	322	*/
	323	static void arcfb_lcd_update_horiz(struct arcfb_par *par, unsigned int left,
	324	unsigned int right, unsigned int top, unsigned int h)
	325	{
	326	unsigned int distance, upper, lower;
	327
	328	distance = h;
	329	upper = floor8(top);
	330	lower = min(upper + distance - 1, ceil64(upper));
	331
	332	while (distance > 0) {
	333	distance -= ((lower - upper) + 1 );
	334	arcfb_lcd_update_vert(par, upper, lower, left, right);
	335	upper = lower + 1;
	336	lower = min(upper + distance - 1, ceil64(upper));
	337	}
	338	}
	339
	340	/*
	341	* here we start the process of spliting out the fb update into
	342	* individual blocks of pixels. we end up spliting into 64x64 blocks
	343	* and finally down to 64x8 pages.
	344	*/
	345	static void arcfb_lcd_update(struct arcfb_par *par, unsigned int dx,
	346	unsigned int dy, unsigned int w, unsigned int h)
	347	{
348	unsigned int left, right, distance, y;
349
350	/* align the request first */
351	y = floor8(dy);
352	h += dy - y;
353	h = iceil8(h);
354
355	distance = w;
356	left = dx;
357	right = min(left + w - 1, ceil64(left));
358
359	while (distance > 0) {
360	arcfb_lcd_update_horiz(par, left, right, y, h);
361	distance -= ((right - left) + 1);
362	left = right + 1;
363	right = min(left + distance - 1, ceil64(left));
364	}
365	}
366
a0aa7d06 AB	367	static void arcfb_fillrect(struct fb_info *info,
a0aa7d06 AB	368	const struct fb_fillrect *rect)
1154ea7d JK	369	{
	370	struct arcfb_par *par = info->par;
	371
	372	cfb_fillrect(info, rect);
	373
	374	/* update the physical lcd */
	375	arcfb_lcd_update(par, rect->dx, rect->dy, rect->width, rect->height);
	376	}
	377
a0aa7d06 AB	378	static void arcfb_copyarea(struct fb_info *info,
a0aa7d06 AB	379	const struct fb_copyarea *area)
1154ea7d JK	380	{
	381	struct arcfb_par *par = info->par;
	382
	383	cfb_copyarea(info, area);
	384
	385	/* update the physical lcd */
	386	arcfb_lcd_update(par, area->dx, area->dy, area->width, area->height);
	387	}
	388
a0aa7d06	389	static void arcfb_imageblit(struct fb_info info, const struct fb_image image)
1154ea7d JK	390	{
	391	struct arcfb_par *par = info->par;
	392
	393	cfb_imageblit(info, image);
	394
	395	/* update the physical lcd */
	396	arcfb_lcd_update(par, image->dx, image->dy, image->width,
	397	image->height);
	398	}
	399
67a6680d CH	400	static int arcfb_ioctl(struct fb_info *info,
67a6680d CH	401	unsigned int cmd, unsigned long arg)
1154ea7d JK	402	{
	403	void __user argp = (void __user )arg;
	404	struct arcfb_par *par = info->par;
	405	unsigned long flags;
	406
	407	switch (cmd) {
	408	case FBIO_WAITEVENT:
	409	{
	410	DEFINE_WAIT(wait);
	411	/* illegal to wait on arc if no irq will occur */
	412	if (!par->irq)
	413	return -EINVAL;
	414
	415	/* wait until the Arc has generated an interrupt
	416	* which will wake us up */
	417	spin_lock_irqsave(&par->lock, flags);
	418	prepare_to_wait(&arcfb_waitq, &wait,
	419	TASK_INTERRUPTIBLE);
	420	spin_unlock_irqrestore(&par->lock, flags);
	421	schedule();
	422	finish_wait(&arcfb_waitq, &wait);
	423	}
	424	case FBIO_GETCONTROL2:
	425	{
	426	unsigned char ctl2;
	427
	428	ctl2 = ks108_readb_ctl2(info->par);
	429	if (copy_to_user(argp, &ctl2, sizeof(ctl2)))
	430	return -EFAULT;
	431	return 0;
	432	}
	433	default:
	434	return -EINVAL;
	435	}
	436	}
	437
	438	/*
	439	* this is the access path from userspace. they can seek and write to
	440	* the fb. it's inefficient for them to do anything less than 64*8
	441	* writes since we update the lcd in each write() anyway.
	442	*/
d2204394	443	static ssize_t arcfb_write(struct file file, const char __user buf, size_t count,
1154ea7d JK	444	loff_t *ppos)
	445	{
	446	/* modded from epson 1355 */
	447
	448	struct inode *inode;
	449	int fbidx;
	450	struct fb_info *info;
	451	unsigned long p;
	452	int err=-EINVAL;
	453	unsigned int fbmemlength,x,y,w,h, bitppos, startpos, endpos, bitcount;
	454	struct arcfb_par *par;
	455	unsigned int xres;
	456
	457	p = *ppos;
ad9a824e	458	inode = file->f_path.dentry->d_inode;
1154ea7d JK	459	fbidx = iminor(inode);
1154ea7d JK	460	info = registered_fb[fbidx];
1154ea7d JK	461
	462	if (!info \|\| !info->screen_base)
	463	return -ENODEV;
	464
939205b2	465	par = info->par;
1154ea7d JK	466	xres = info->var.xres;
	467	fbmemlength = (xres * info->var.yres)/8;
	468
	469	if (p > fbmemlength)
	470	return -ENOSPC;
	471
	472	err = 0;
	473	if ((count + p) > fbmemlength) {
	474	count = fbmemlength - p;
	475	err = -ENOSPC;
	476	}
	477
	478	if (count) {
	479	char *base_addr;
	480
d2e8d369	481	base_addr = (char __force *)info->screen_base;
1154ea7d JK	482	count -= copy_from_user(base_addr + p, buf, count);
	483	*ppos += count;
	484	err = -EFAULT;
	485	}
	486
	487
	488	bitppos = p*8;
	489	startpos = floorXres(bitppos, xres);
	490	endpos = ceilXres((bitppos + (count*8)), xres);
	491	bitcount = endpos - startpos;
	492
	493	x = startpos % xres;
	494	y = startpos / xres;
	495	w = xres;
	496	h = bitcount / xres;
	497	arcfb_lcd_update(par, x, y, w, h);
	498
	499	if (count)
	500	return count;
	501	return err;
	502	}
	503
1154ea7d JK	504	static struct fb_ops arcfb_ops = {
	505	.owner = THIS_MODULE,
	506	.fb_open = arcfb_open,
	507	.fb_write = arcfb_write,
	508	.fb_release = arcfb_release,
	509	.fb_pan_display = arcfb_pan_display,
	510	.fb_fillrect = arcfb_fillrect,
	511	.fb_copyarea = arcfb_copyarea,
	512	.fb_imageblit = arcfb_imageblit,
1154ea7d JK	513	.fb_ioctl = arcfb_ioctl,
	514	};
	515
3ae5eaec	516	static int __init arcfb_probe(struct platform_device *dev)
1154ea7d	517	{
1154ea7d JK	518	struct fb_info *info;
	519	int retval = -ENOMEM;
	520	int videomemorysize;
	521	unsigned char *videomemory;
	522	struct arcfb_par *par;
	523	int i;
	524
	525	videomemorysize = (((6464)num_cols)*num_rows)/8;
	526
	527	/* We need a flat backing store for the Arc's
	528	less-flat actual paged framebuffer */
	529	if (!(videomemory = vmalloc(videomemorysize)))
	530	return retval;
	531
	532	memset(videomemory, 0, videomemorysize);
	533
	534	info = framebuffer_alloc(sizeof(struct arcfb_par), &dev->dev);
	535	if (!info)
	536	goto err;
	537
	538	info->screen_base = (char __iomem *)videomemory;
	539	info->fbops = &arcfb_ops;
	540
	541	info->var = arcfb_var;
	542	info->fix = arcfb_fix;
	543	par = info->par;
	544	par->info = info;
	545
	546	if (!dio_addr \|\| !cio_addr \|\| !c2io_addr) {
	547	printk(KERN_WARNING "no IO addresses supplied\n");
	548	goto err1;
	549	}
	550	par->dio_addr = dio_addr;
	551	par->cio_addr = cio_addr;
	552	par->c2io_addr = c2io_addr;
	553	par->cslut[0] = 0x00;
	554	par->cslut[1] = 0x06;
	555	info->flags = FBINFO_FLAG_DEFAULT;
	556	spin_lock_init(&par->lock);
	557	retval = register_framebuffer(info);
	558	if (retval < 0)
	559	goto err1;
3ae5eaec	560	platform_set_drvdata(dev, info);
1154ea7d JK	561	if (irq) {
1154ea7d JK	562	par->irq = irq;
63a43399	563	if (request_irq(par->irq, &arcfb_interrupt, IRQF_SHARED,
1154ea7d JK	564	"arcfb", info)) {
	565	printk(KERN_INFO
	566	"arcfb: Failed req IRQ %d\n", par->irq);
	567	goto err1;
	568	}
	569	}
	570	printk(KERN_INFO
	571	"fb%d: Arc frame buffer device, using %dK of video memory\n",
	572	info->node, videomemorysize >> 10);
	573
	574	/* this inits the lcd but doesn't clear dirty pixels */
	575	for (i = 0; i < num_cols * num_rows; i++) {
	576	ks108_writeb_ctl(par, i, KS_DPY_OFF);
	577	ks108_set_start_line(par, i, 0);
	578	ks108_set_yaddr(par, i, 0);
	579	ks108_set_xaddr(par, i, 0);
	580	ks108_writeb_ctl(par, i, KS_DPY_ON);
	581	}
	582
	583	/* if we were told to splash the screen, we just clear it */
	584	if (!nosplash) {
	585	for (i = 0; i < num_cols * num_rows; i++) {
	586	printk(KERN_INFO "fb%d: splashing lcd %d\n",
	587	info->node, i);
	588	ks108_set_start_line(par, i, 0);
	589	ks108_clear_lcd(par, i);
	590	}
	591	}
	592
	593	return 0;
	594	err1:
	595	framebuffer_release(info);
	596	err:
	597	vfree(videomemory);
	598	return retval;
	599	}
	600
3ae5eaec	601	static int arcfb_remove(struct platform_device *dev)
1154ea7d	602	{
3ae5eaec	603	struct fb_info *info = platform_get_drvdata(dev);
1154ea7d JK	604
	605	if (info) {
	606	unregister_framebuffer(info);
d2e8d369	607	vfree((void __force *)info->screen_base);
1154ea7d JK	608	framebuffer_release(info);
	609	}
	610	return 0;
	611	}
	612
3ae5eaec	613	static struct platform_driver arcfb_driver = {
1154ea7d JK	614	.probe = arcfb_probe,
1154ea7d JK	615	.remove = arcfb_remove,
3ae5eaec RK	616	.driver = {
	617	.name = "arcfb",
	618	},
1154ea7d JK	619	};
1154ea7d JK	620
8d972a96	621	static struct platform_device *arcfb_device;
1154ea7d JK	622
	623	static int __init arcfb_init(void)
	624	{
	625	int ret;
	626
	627	if (!arcfb_enable)
	628	return -ENXIO;
	629
3ae5eaec	630	ret = platform_driver_register(&arcfb_driver);
1154ea7d	631	if (!ret) {
8d972a96 RK	632	arcfb_device = platform_device_alloc("arcfb", 0);
	633	if (arcfb_device) {
	634	ret = platform_device_add(arcfb_device);
	635	} else {
	636	ret = -ENOMEM;
	637	}
	638	if (ret) {
	639	platform_device_put(arcfb_device);
3ae5eaec	640	platform_driver_unregister(&arcfb_driver);
8d972a96	641	}
1154ea7d JK	642	}
	643	return ret;
	644
	645	}
	646
	647	static void __exit arcfb_exit(void)
	648	{
8d972a96	649	platform_device_unregister(arcfb_device);
3ae5eaec	650	platform_driver_unregister(&arcfb_driver);
1154ea7d JK	651	}
	652
	653	module_param(num_cols, ulong, 0);
	654	MODULE_PARM_DESC(num_cols, "Num horiz panels, eg: 2 = 128 bit wide");
	655	module_param(num_rows, ulong, 0);
	656	MODULE_PARM_DESC(num_rows, "Num vert panels, eg: 1 = 64 bit high");
	657	module_param(nosplash, uint, 0);
	658	MODULE_PARM_DESC(nosplash, "Disable doing the splash screen");
	659	module_param(arcfb_enable, uint, 0);
	660	MODULE_PARM_DESC(arcfb_enable, "Enable communication with Arc board");
	661	module_param(dio_addr, ulong, 0);
	662	MODULE_PARM_DESC(dio_addr, "IO address for data, eg: 0x480");
	663	module_param(cio_addr, ulong, 0);
	664	MODULE_PARM_DESC(cio_addr, "IO address for control, eg: 0x400");
	665	module_param(c2io_addr, ulong, 0);
	666	MODULE_PARM_DESC(c2io_addr, "IO address for secondary control, eg: 0x408");
	667	module_param(splashval, ulong, 0);
	668	MODULE_PARM_DESC(splashval, "Splash pattern: 0xFF is black, 0x00 is green");
	669	module_param(tuhold, ulong, 0);
	670	MODULE_PARM_DESC(tuhold, "Time to hold between strobing data to Arc board");
	671	module_param(irq, uint, 0);
	672	MODULE_PARM_DESC(irq, "IRQ for the Arc board");
	673
	674	module_init(arcfb_init);
	675	module_exit(arcfb_exit);
	676
	677	MODULE_DESCRIPTION("fbdev driver for Arc monochrome LCD board");
	678	MODULE_AUTHOR("Jaya Kumar");
	679	MODULE_LICENSE("GPL");
	680