Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc-merge
[linux-2.6] / drivers / video / arcfb.c
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>
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>
50 #include <linux/platform_device.h>
51
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
74 struct 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
85 static 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
95 static 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
104 static unsigned long num_cols;
105 static unsigned long num_rows;
106 static unsigned long dio_addr;
107 static unsigned long cio_addr;
108 static unsigned long c2io_addr;
109 static unsigned long splashval;
110 static unsigned long tuhold;
111 static unsigned int nosplash;
112 static unsigned int arcfb_enable;
113 static unsigned int irq;
114
115 static DECLARE_WAIT_QUEUE_HEAD(arcfb_waitq);
116
117 static 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
128 static void ks108_writeb_mainctl(struct arcfb_par *par, unsigned char value)
129 {
130
131         outb(value, par->cio_addr);
132         udelay(tuhold);
133 }
134
135 static unsigned char ks108_readb_ctl2(struct arcfb_par *par)
136 {
137         return inb(par->c2io_addr);
138 }
139
140 static 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
151 static 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
157 static 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
163 static 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
169 static 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
185 static 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
193 static 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
204 static 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
222 static 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  */
251 static 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  */
303 static 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  */
325 static 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  */
347 static 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
369 static void arcfb_fillrect(struct fb_info *info,
370                            const struct fb_fillrect *rect)
371 {
372         struct arcfb_par *par = info->par;
373
374         cfb_fillrect(info, rect);
375
376         /* update the physical lcd */
377         arcfb_lcd_update(par, rect->dx, rect->dy, rect->width, rect->height);
378 }
379
380 static void arcfb_copyarea(struct fb_info *info,
381                            const struct fb_copyarea *area)
382 {
383         struct arcfb_par *par = info->par;
384
385         cfb_copyarea(info, area);
386
387         /* update the physical lcd */
388         arcfb_lcd_update(par, area->dx, area->dy, area->width, area->height);
389 }
390
391 static void arcfb_imageblit(struct fb_info *info, const struct fb_image *image)
392 {
393         struct arcfb_par *par = info->par;
394
395         cfb_imageblit(info, image);
396
397         /* update the physical lcd */
398         arcfb_lcd_update(par, image->dx, image->dy, image->width,
399                                 image->height);
400 }
401
402 static int arcfb_ioctl(struct fb_info *info,
403                           unsigned int cmd, unsigned long arg)
404 {
405         void __user *argp = (void __user *)arg;
406         struct arcfb_par *par = info->par;
407         unsigned long flags;
408
409         switch (cmd) {
410                 case FBIO_WAITEVENT:
411                 {
412                         DEFINE_WAIT(wait);
413                         /* illegal to wait on arc if no irq will occur */
414                         if (!par->irq)
415                                 return -EINVAL;
416
417                         /* wait until the Arc has generated an interrupt
418                          * which will wake us up */
419                         spin_lock_irqsave(&par->lock, flags);
420                         prepare_to_wait(&arcfb_waitq, &wait,
421                                         TASK_INTERRUPTIBLE);
422                         spin_unlock_irqrestore(&par->lock, flags);
423                         schedule();
424                         finish_wait(&arcfb_waitq, &wait);
425                 }
426                 case FBIO_GETCONTROL2:
427                 {
428                         unsigned char ctl2;
429
430                         ctl2 = ks108_readb_ctl2(info->par);
431                         if (copy_to_user(argp, &ctl2, sizeof(ctl2)))
432                                 return -EFAULT;
433                         return 0;
434                 }
435                 default:
436                         return -EINVAL;
437         }
438 }
439
440 /*
441  * this is the access path from userspace. they can seek and write to
442  * the fb. it's inefficient for them to do anything less than 64*8
443  * writes since we update the lcd in each write() anyway.
444  */
445 static ssize_t arcfb_write(struct file *file, const char __user *buf, size_t count,
446                                 loff_t *ppos)
447 {
448         /* modded from epson 1355 */
449
450         struct inode *inode;
451         int fbidx;
452         struct fb_info *info;
453         unsigned long p;
454         int err=-EINVAL;
455         unsigned int fbmemlength,x,y,w,h, bitppos, startpos, endpos, bitcount;
456         struct arcfb_par *par;
457         unsigned int xres;
458
459         p = *ppos;
460         inode = file->f_dentry->d_inode;
461         fbidx = iminor(inode);
462         info = registered_fb[fbidx];
463         par = info->par;
464
465         if (!info || !info->screen_base)
466                 return -ENODEV;
467
468         xres = info->var.xres;
469         fbmemlength = (xres * info->var.yres)/8;
470
471         if (p > fbmemlength)
472                 return -ENOSPC;
473
474         err = 0;
475         if ((count + p) > fbmemlength) {
476                 count = fbmemlength - p;
477                 err = -ENOSPC;
478         }
479
480         if (count) {
481                 char *base_addr;
482
483                 base_addr = info->screen_base;
484                 count -= copy_from_user(base_addr + p, buf, count);
485                 *ppos += count;
486                 err = -EFAULT;
487         }
488
489
490         bitppos = p*8;
491         startpos = floorXres(bitppos, xres);
492         endpos = ceilXres((bitppos + (count*8)), xres);
493         bitcount = endpos - startpos;
494
495         x = startpos % xres;
496         y = startpos / xres;
497         w = xres;
498         h = bitcount / xres;
499         arcfb_lcd_update(par, x, y, w, h);
500
501         if (count)
502                 return count;
503         return err;
504 }
505
506 static struct fb_ops arcfb_ops = {
507         .owner          = THIS_MODULE,
508         .fb_open        = arcfb_open,
509         .fb_write       = arcfb_write,
510         .fb_release     = arcfb_release,
511         .fb_pan_display = arcfb_pan_display,
512         .fb_fillrect    = arcfb_fillrect,
513         .fb_copyarea    = arcfb_copyarea,
514         .fb_imageblit   = arcfb_imageblit,
515         .fb_ioctl       = arcfb_ioctl,
516 };
517
518 static int __init arcfb_probe(struct platform_device *dev)
519 {
520         struct fb_info *info;
521         int retval = -ENOMEM;
522         int videomemorysize;
523         unsigned char *videomemory;
524         struct arcfb_par *par;
525         int i;
526
527         videomemorysize = (((64*64)*num_cols)*num_rows)/8;
528
529         /* We need a flat backing store for the Arc's
530            less-flat actual paged framebuffer */
531         if (!(videomemory = vmalloc(videomemorysize)))
532                 return retval;
533
534         memset(videomemory, 0, videomemorysize);
535
536         info = framebuffer_alloc(sizeof(struct arcfb_par), &dev->dev);
537         if (!info)
538                 goto err;
539
540         info->screen_base = (char __iomem *)videomemory;
541         info->fbops = &arcfb_ops;
542
543         info->var = arcfb_var;
544         info->fix = arcfb_fix;
545         par = info->par;
546         par->info = info;
547
548         if (!dio_addr || !cio_addr || !c2io_addr) {
549                 printk(KERN_WARNING "no IO addresses supplied\n");
550                 goto err1;
551         }
552         par->dio_addr = dio_addr;
553         par->cio_addr = cio_addr;
554         par->c2io_addr = c2io_addr;
555         par->cslut[0] = 0x00;
556         par->cslut[1] = 0x06;
557         info->flags = FBINFO_FLAG_DEFAULT;
558         spin_lock_init(&par->lock);
559         retval = register_framebuffer(info);
560         if (retval < 0)
561                 goto err1;
562         platform_set_drvdata(dev, info);
563         if (irq) {
564                 par->irq = irq;
565                 if (request_irq(par->irq, &arcfb_interrupt, SA_SHIRQ,
566                                 "arcfb", info)) {
567                         printk(KERN_INFO
568                                 "arcfb: Failed req IRQ %d\n", par->irq);
569                         goto err1;
570                 }
571         }
572         printk(KERN_INFO
573                "fb%d: Arc frame buffer device, using %dK of video memory\n",
574                info->node, videomemorysize >> 10);
575
576         /* this inits the lcd but doesn't clear dirty pixels */
577         for (i = 0; i < num_cols * num_rows; i++) {
578                 ks108_writeb_ctl(par, i, KS_DPY_OFF);
579                 ks108_set_start_line(par, i, 0);
580                 ks108_set_yaddr(par, i, 0);
581                 ks108_set_xaddr(par, i, 0);
582                 ks108_writeb_ctl(par, i, KS_DPY_ON);
583         }
584
585         /* if we were told to splash the screen, we just clear it */
586         if (!nosplash) {
587                 for (i = 0; i < num_cols * num_rows; i++) {
588                         printk(KERN_INFO "fb%d: splashing lcd %d\n",
589                                 info->node, i);
590                         ks108_set_start_line(par, i, 0);
591                         ks108_clear_lcd(par, i);
592                 }
593         }
594
595         return 0;
596 err1:
597         framebuffer_release(info);
598 err:
599         vfree(videomemory);
600         return retval;
601 }
602
603 static int arcfb_remove(struct platform_device *dev)
604 {
605         struct fb_info *info = platform_get_drvdata(dev);
606
607         if (info) {
608                 unregister_framebuffer(info);
609                 vfree(info->screen_base);
610                 framebuffer_release(info);
611         }
612         return 0;
613 }
614
615 static struct platform_driver arcfb_driver = {
616         .probe  = arcfb_probe,
617         .remove = arcfb_remove,
618         .driver = {
619                 .name   = "arcfb",
620         },
621 };
622
623 static struct platform_device *arcfb_device;
624
625 static int __init arcfb_init(void)
626 {
627         int ret;
628
629         if (!arcfb_enable)
630                 return -ENXIO;
631
632         ret = platform_driver_register(&arcfb_driver);
633         if (!ret) {
634                 arcfb_device = platform_device_alloc("arcfb", 0);
635                 if (arcfb_device) {
636                         ret = platform_device_add(arcfb_device);
637                 } else {
638                         ret = -ENOMEM;
639                 }
640                 if (ret) {
641                         platform_device_put(arcfb_device);
642                         platform_driver_unregister(&arcfb_driver);
643                 }
644         }
645         return ret;
646
647 }
648
649 static void __exit arcfb_exit(void)
650 {
651         platform_device_unregister(arcfb_device);
652         platform_driver_unregister(&arcfb_driver);
653 }
654
655 module_param(num_cols, ulong, 0);
656 MODULE_PARM_DESC(num_cols, "Num horiz panels, eg: 2 = 128 bit wide");
657 module_param(num_rows, ulong, 0);
658 MODULE_PARM_DESC(num_rows, "Num vert panels, eg: 1 = 64 bit high");
659 module_param(nosplash, uint, 0);
660 MODULE_PARM_DESC(nosplash, "Disable doing the splash screen");
661 module_param(arcfb_enable, uint, 0);
662 MODULE_PARM_DESC(arcfb_enable, "Enable communication with Arc board");
663 module_param(dio_addr, ulong, 0);
664 MODULE_PARM_DESC(dio_addr, "IO address for data, eg: 0x480");
665 module_param(cio_addr, ulong, 0);
666 MODULE_PARM_DESC(cio_addr, "IO address for control, eg: 0x400");
667 module_param(c2io_addr, ulong, 0);
668 MODULE_PARM_DESC(c2io_addr, "IO address for secondary control, eg: 0x408");
669 module_param(splashval, ulong, 0);
670 MODULE_PARM_DESC(splashval, "Splash pattern: 0xFF is black, 0x00 is green");
671 module_param(tuhold, ulong, 0);
672 MODULE_PARM_DESC(tuhold, "Time to hold between strobing data to Arc board");
673 module_param(irq, uint, 0);
674 MODULE_PARM_DESC(irq, "IRQ for the Arc board");
675
676 module_init(arcfb_init);
677 module_exit(arcfb_exit);
678
679 MODULE_DESCRIPTION("fbdev driver for Arc monochrome LCD board");
680 MODULE_AUTHOR("Jaya Kumar");
681 MODULE_LICENSE("GPL");
682