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