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