arcfb.c 17 KB

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