2 * linux/drivers/video/arcfb.c -- FB driver for Arc monochrome LCD board
4 * Copyright (C) 2005, Jaya Kumar <jayalk@intworks.biz>
5 * http://www.intworks.biz/arclcd
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
11 * Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven.
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
26 * - testing with interrupt hw
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
37 #include <linux/module.h>
38 #include <linux/kernel.h>
39 #include <linux/errno.h>
40 #include <linux/string.h>
42 #include <linux/tty.h>
43 #include <linux/slab.h>
44 #include <linux/vmalloc.h>
45 #include <linux/delay.h>
46 #include <linux/interrupt.h>
48 #include <linux/init.h>
49 #include <linux/arcfb.h>
51 #include <asm/uaccess.h>
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))
59 /* ks108 chipset specific defines and code */
61 #define KS_SET_DPY_START_LINE 0xC0
62 #define KS_SET_PAGE_NUM 0xB8
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
74 unsigned long dio_addr;
75 unsigned long cio_addr;
76 unsigned long c2io_addr;
78 unsigned char cslut[9];
84 static struct fb_fix_screeninfo arcfb_fix __initdata = {
86 .type = FB_TYPE_PACKED_PIXELS,
87 .visual = FB_VISUAL_MONO01,
91 .accel = FB_ACCEL_NONE,
94 static struct fb_var_screeninfo arcfb_var __initdata = {
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;
114 static DECLARE_WAIT_QUEUE_HEAD(arcfb_waitq);
116 static void ks108_writeb_ctl(struct arcfb_par *par,
117 unsigned int chipindex, unsigned char value)
119 unsigned char chipselval = par->cslut[chipindex];
121 outb(chipselval|KS_CEHI|KS_SEL_CMD, par->cio_addr);
122 outb(value, par->dio_addr);
124 outb(chipselval|KS_CELO|KS_SEL_CMD, par->cio_addr);
127 static void ks108_writeb_mainctl(struct arcfb_par *par, unsigned char value)
130 outb(value, par->cio_addr);
134 static unsigned char ks108_readb_ctl2(struct arcfb_par *par)
136 return inb(par->c2io_addr);
139 static void ks108_writeb_data(struct arcfb_par *par,
140 unsigned int chipindex, unsigned char value)
142 unsigned char chipselval = par->cslut[chipindex];
144 outb(chipselval|KS_CEHI|KS_SEL_DATA, par->cio_addr);
145 outb(value, par->dio_addr);
147 outb(chipselval|KS_CELO|KS_SEL_DATA, par->cio_addr);
150 static void ks108_set_start_line(struct arcfb_par *par,
151 unsigned int chipindex, unsigned char y)
153 ks108_writeb_ctl(par, chipindex, KS_SET_DPY_START_LINE|y);
156 static void ks108_set_yaddr(struct arcfb_par *par,
157 unsigned int chipindex, unsigned char y)
159 ks108_writeb_ctl(par, chipindex, KS_SET_PAGE_NUM|y);
162 static void ks108_set_xaddr(struct arcfb_par *par,
163 unsigned int chipindex, unsigned char x)
165 ks108_writeb_ctl(par, chipindex, KS_SET_X|x);
168 static void ks108_clear_lcd(struct arcfb_par *par, unsigned int chipindex)
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);
182 /* main arcfb functions */
184 static int arcfb_open(struct fb_info *info, int user)
186 struct arcfb_par *par = info->par;
188 atomic_inc(&par->ref_count);
192 static int arcfb_release(struct fb_info *info, int user)
194 struct arcfb_par *par = info->par;
195 int count = atomic_read(&par->ref_count);
199 atomic_dec(&par->ref_count);
203 static int arcfb_pan_display(struct fb_var_screeninfo *var,
204 struct fb_info *info)
207 struct arcfb_par *par = info->par;
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);
214 info->var.yoffset = var->yoffset;
221 static irqreturn_t arcfb_interrupt(int vec, void *dev_instance,
222 struct pt_regs *regs)
224 struct fb_info *info = dev_instance;
225 unsigned char ctl2status;
226 struct arcfb_par *par = info->par;
228 ctl2status = ks108_readb_ctl2(par);
230 if (!(ctl2status & KS_INTACK)) /* not arc generated interrupt */
233 ks108_writeb_mainctl(par, KS_CLRINT);
235 spin_lock(&par->lock);
236 if (waitqueue_active(&arcfb_waitq)) {
237 wake_up(&arcfb_waitq);
239 spin_unlock(&par->lock);
245 * here we handle a specific page on the lcd. the complexity comes from
246 * the fact that the fb is laidout in 8xX vertical columns. we extract
247 * each write of 8 vertical pixels. then we shift out as we move along
248 * X. That's what rightshift does. bitmask selects the desired input bit.
250 static void arcfb_lcd_update_page(struct arcfb_par *par, unsigned int upper,
251 unsigned int left, unsigned int right, unsigned int distance)
254 unsigned int xindex, yindex, chipindex, linesize;
257 unsigned char bitmask, rightshift;
261 chipindex = (xindex + (yindex*num_cols));
263 ks108_set_yaddr(par, chipindex, upper/8);
265 linesize = par->info->var.xres/8;
266 src = par->info->screen_base + (left/8) + (upper * linesize);
267 ks108_set_xaddr(par, chipindex, left);
271 while (left <= right) {
273 for (i = 0; i < 8; i++) {
274 if ( i > rightshift) {
275 val |= (*(src + (i*linesize)) & bitmask)
278 val |= (*(src + (i*linesize)) & bitmask)
282 ks108_writeb_data(par, chipindex, val);
285 if (bitmask == 0x80) {
297 * here we handle the entire vertical page of the update. we write across
298 * lcd chips. update_page uses the upper/left values to decide which
299 * chip to select for the right. upper is needed for setting the page
300 * desired for the write.
302 static void arcfb_lcd_update_vert(struct arcfb_par *par, unsigned int top,
303 unsigned int bottom, unsigned int left, unsigned int right)
305 unsigned int distance, upper, lower;
307 distance = (bottom - top) + 1;
311 while (distance > 0) {
313 arcfb_lcd_update_page(par, upper, left, right, 8);
320 * here we handle horizontal blocks for the update. update_vert will
321 * handle spaning multiple pages. we break out each horizontal
322 * block in to individual blocks no taller than 64 pixels.
324 static void arcfb_lcd_update_horiz(struct arcfb_par *par, unsigned int left,
325 unsigned int right, unsigned int top, unsigned int h)
327 unsigned int distance, upper, lower;
331 lower = min(upper + distance - 1, ceil64(upper));
333 while (distance > 0) {
334 distance -= ((lower - upper) + 1 );
335 arcfb_lcd_update_vert(par, upper, lower, left, right);
337 lower = min(upper + distance - 1, ceil64(upper));
342 * here we start the process of spliting out the fb update into
343 * individual blocks of pixels. we end up spliting into 64x64 blocks
344 * and finally down to 64x8 pages.
346 static void arcfb_lcd_update(struct arcfb_par *par, unsigned int dx,
347 unsigned int dy, unsigned int w, unsigned int h)
349 unsigned int left, right, distance, y;
351 /* align the request first */
358 right = min(left + w - 1, ceil64(left));
360 while (distance > 0) {
361 arcfb_lcd_update_horiz(par, left, right, y, h);
362 distance -= ((right - left) + 1);
364 right = min(left + distance - 1, ceil64(left));
368 void arcfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
370 struct arcfb_par *par = info->par;
372 cfb_fillrect(info, rect);
374 /* update the physical lcd */
375 arcfb_lcd_update(par, rect->dx, rect->dy, rect->width, rect->height);
378 void arcfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
380 struct arcfb_par *par = info->par;
382 cfb_copyarea(info, area);
384 /* update the physical lcd */
385 arcfb_lcd_update(par, area->dx, area->dy, area->width, area->height);
388 void arcfb_imageblit(struct fb_info *info, const struct fb_image *image)
390 struct arcfb_par *par = info->par;
392 cfb_imageblit(info, image);
394 /* update the physical lcd */
395 arcfb_lcd_update(par, image->dx, image->dy, image->width,
399 static int arcfb_ioctl(struct inode *inode, struct file *file,
400 unsigned int cmd, unsigned long arg,
401 struct fb_info *info)
403 void __user *argp = (void __user *)arg;
404 struct arcfb_par *par = info->par;
411 /* illegal to wait on arc if no irq will occur */
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,
420 spin_unlock_irqrestore(&par->lock, flags);
422 finish_wait(&arcfb_waitq, &wait);
424 case FBIO_GETCONTROL2:
428 ctl2 = ks108_readb_ctl2(info->par);
429 if (copy_to_user(argp, &ctl2, sizeof(ctl2)))
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.
443 static ssize_t arcfb_write(struct file *file, const char *buf, size_t count,
446 /* modded from epson 1355 */
450 struct fb_info *info;
453 unsigned int fbmemlength,x,y,w,h, bitppos, startpos, endpos, bitcount;
454 struct arcfb_par *par;
458 inode = file->f_dentry->d_inode;
459 fbidx = iminor(inode);
460 info = registered_fb[fbidx];
463 if (!info || !info->screen_base)
466 xres = info->var.xres;
467 fbmemlength = (xres * info->var.yres)/8;
473 if ((count + p) > fbmemlength) {
474 count = fbmemlength - p;
481 base_addr = info->screen_base;
482 count -= copy_from_user(base_addr + p, buf, count);
489 startpos = floorXres(bitppos, xres);
490 endpos = ceilXres((bitppos + (count*8)), xres);
491 bitcount = endpos - startpos;
497 arcfb_lcd_update(par, x, y, w, h);
504 static void arcfb_platform_release(struct device *device)
508 static struct fb_ops arcfb_ops = {
509 .owner = THIS_MODULE,
510 .fb_open = arcfb_open,
511 .fb_write = arcfb_write,
512 .fb_release = arcfb_release,
513 .fb_pan_display = arcfb_pan_display,
514 .fb_fillrect = arcfb_fillrect,
515 .fb_copyarea = arcfb_copyarea,
516 .fb_imageblit = arcfb_imageblit,
517 .fb_cursor = soft_cursor,
518 .fb_ioctl = arcfb_ioctl,
521 static int __init arcfb_probe(struct device *device)
523 struct platform_device *dev = to_platform_device(device);
524 struct fb_info *info;
525 int retval = -ENOMEM;
527 unsigned char *videomemory;
528 struct arcfb_par *par;
531 videomemorysize = (((64*64)*num_cols)*num_rows)/8;
533 /* We need a flat backing store for the Arc's
534 less-flat actual paged framebuffer */
535 if (!(videomemory = vmalloc(videomemorysize)))
538 memset(videomemory, 0, videomemorysize);
540 info = framebuffer_alloc(sizeof(struct arcfb_par), &dev->dev);
544 info->screen_base = (char __iomem *)videomemory;
545 info->fbops = &arcfb_ops;
547 info->var = arcfb_var;
548 info->fix = arcfb_fix;
552 if (!dio_addr || !cio_addr || !c2io_addr) {
553 printk(KERN_WARNING "no IO addresses supplied\n");
556 par->dio_addr = dio_addr;
557 par->cio_addr = cio_addr;
558 par->c2io_addr = c2io_addr;
559 par->cslut[0] = 0x00;
560 par->cslut[1] = 0x06;
561 info->flags = FBINFO_FLAG_DEFAULT;
562 spin_lock_init(&par->lock);
563 retval = register_framebuffer(info);
566 dev_set_drvdata(&dev->dev, info);
569 if (request_irq(par->irq, &arcfb_interrupt, SA_SHIRQ,
572 "arcfb: Failed req IRQ %d\n", par->irq);
577 "fb%d: Arc frame buffer device, using %dK of video memory\n",
578 info->node, videomemorysize >> 10);
580 /* this inits the lcd but doesn't clear dirty pixels */
581 for (i = 0; i < num_cols * num_rows; i++) {
582 ks108_writeb_ctl(par, i, KS_DPY_OFF);
583 ks108_set_start_line(par, i, 0);
584 ks108_set_yaddr(par, i, 0);
585 ks108_set_xaddr(par, i, 0);
586 ks108_writeb_ctl(par, i, KS_DPY_ON);
589 /* if we were told to splash the screen, we just clear it */
591 for (i = 0; i < num_cols * num_rows; i++) {
592 printk(KERN_INFO "fb%d: splashing lcd %d\n",
594 ks108_set_start_line(par, i, 0);
595 ks108_clear_lcd(par, i);
601 framebuffer_release(info);
607 static int arcfb_remove(struct device *device)
609 struct fb_info *info = dev_get_drvdata(device);
612 unregister_framebuffer(info);
613 vfree(info->screen_base);
614 framebuffer_release(info);
619 static struct device_driver arcfb_driver = {
621 .bus = &platform_bus_type,
622 .probe = arcfb_probe,
623 .remove = arcfb_remove,
626 static struct platform_device arcfb_device = {
630 .release = arcfb_platform_release,
634 static int __init arcfb_init(void)
641 ret = driver_register(&arcfb_driver);
643 ret = platform_device_register(&arcfb_device);
645 driver_unregister(&arcfb_driver);
651 static void __exit arcfb_exit(void)
653 platform_device_unregister(&arcfb_device);
654 driver_unregister(&arcfb_driver);
657 module_param(num_cols, ulong, 0);
658 MODULE_PARM_DESC(num_cols, "Num horiz panels, eg: 2 = 128 bit wide");
659 module_param(num_rows, ulong, 0);
660 MODULE_PARM_DESC(num_rows, "Num vert panels, eg: 1 = 64 bit high");
661 module_param(nosplash, uint, 0);
662 MODULE_PARM_DESC(nosplash, "Disable doing the splash screen");
663 module_param(arcfb_enable, uint, 0);
664 MODULE_PARM_DESC(arcfb_enable, "Enable communication with Arc board");
665 module_param(dio_addr, ulong, 0);
666 MODULE_PARM_DESC(dio_addr, "IO address for data, eg: 0x480");
667 module_param(cio_addr, ulong, 0);
668 MODULE_PARM_DESC(cio_addr, "IO address for control, eg: 0x400");
669 module_param(c2io_addr, ulong, 0);
670 MODULE_PARM_DESC(c2io_addr, "IO address for secondary control, eg: 0x408");
671 module_param(splashval, ulong, 0);
672 MODULE_PARM_DESC(splashval, "Splash pattern: 0xFF is black, 0x00 is green");
673 module_param(tuhold, ulong, 0);
674 MODULE_PARM_DESC(tuhold, "Time to hold between strobing data to Arc board");
675 module_param(irq, uint, 0);
676 MODULE_PARM_DESC(irq, "IRQ for the Arc board");
678 module_init(arcfb_init);
679 module_exit(arcfb_exit);
681 MODULE_DESCRIPTION("fbdev driver for Arc monochrome LCD board");
682 MODULE_AUTHOR("Jaya Kumar");
683 MODULE_LICENSE("GPL");