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

source code of linux/drivers/video/fbdev/arcfb.c