arcfb.c 17 KB

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