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