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