开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
tuball.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：13k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

tuball.c：源码内容
  1. /*
  2.  *  IBM/3270 Driver -- Copyright (C) 2000 UTS Global LLC
  3.  *
  4.  *  tuball.c -- Initialization, termination, irq lookup
  5.  *
  6.  *
  7.  *
  8.  *
  9.  *
  10.  *  Author:  Richard Hitt
  11.  */
  12. #include <linux/config.h>
  13. #include "tubio.h"
  14. #ifndef MODULE
  15. #include <linux/init.h>
  16. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0))
  17. #include <asm/cpcmd.h>
  18. #include <linux/bootmem.h>
  19. #else
  20. #include "../../../../arch/s390/kernel/cpcmd.h"
  21. #endif
  22. #endif
  24. /* Module parameters */
  25. int tubdebug;
  26. int tubscrolltime = -1;
  27. int tubxcorrect = 1;            /* Do correct ebc<->asc tables */
  28. #ifdef MODULE
  29. MODULE_PARM(tubdebug, "i");
  30. MODULE_PARM(tubscrolltime, "i");
  31. MODULE_PARM(tubxcorrect, "i");
  32. #endif
  33. /*
  34.  * Values for tubdebug and their effects:
  35.  * 1 - print in hex on console the first 16 bytes received
  36.  * 2 - print address at which array tubminors is allocated
  37.  * 4 - attempt to register tty3270_driver
  38.  */
  39. int tubnummins;
  40. tub_t *(*tubminors)[TUBMAXMINS];
  41. tub_t *(*(*tubirqs)[256])[256];
  42. unsigned char tub_ascebc[256];
  43. unsigned char tub_ebcasc[256];
  44. int tubinitminors(void);
  45. void tubfiniminors(void);
  46. void tubint(int, void *, struct pt_regs *);
  48. /* Lookup-by-irq functions */
  49. int tubaddbyirq(tub_t *, int);
  50. tub_t *tubfindbyirq(int);
  51. void tubdelbyirq(tub_t *, int);
  52. void tubfiniirqs(void);
  54. extern int fs3270_init(void);
  55. extern void fs3270_fini(void);
  56. extern int tty3270_init(void);
  57. extern void tty3270_fini(void);
  59. unsigned char tub_ebcgraf[64] =
  60. { 0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
  61.   0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
  62.   0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
  63.   0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
  64.   0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
  65.   0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  66.   0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
  67.   0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f };
  69. int tub3270_init(void);
  71. #ifndef MODULE
  73. /*
  74.  * Can't have this driver a module & support console at the same time
  75.  */
  76. #ifdef CONFIG_TN3270_CONSOLE
  77. static kdev_t tub3270_con_device(struct console *);
  78. static void tub3270_con_unblank(void);
  79. static void tub3270_con_write(struct console *, const char *,
  80. unsigned int);
  82. static struct console tub3270_con = {
  83. "tub3270", /* name */
  84. tub3270_con_write, /* write */
  85. NULL, /* read */
  86. tub3270_con_device, /* device */
  87. tub3270_con_unblank, /* unblank */
  88. NULL, /* setup */
  89. CON_PRINTBUFFER, /* flags */
  90. 0, /* index */
  91. 0, /* cflag */
  92. NULL /* next */
  93. };
  95. static bcb_t tub3270_con_bcb; /* Buffer that receives con writes */
  96. static spinlock_t tub3270_con_bcblock; /* Lock for the buffer */
  97. int tub3270_con_irq = -1; /* set nonneg by _activate() */
  98. tub_t *tub3270_con_tubp; /* set nonzero by _activate() */
  99. struct tty_driver tty3270_con_driver; /* for /dev/console at 4, 64 */
  101. #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0))
  102. int tub3270_con_devno = -1; /* set by tub3270_con_setup() */
  103. __initfunc(void tub3270_con_setup(char *str, int *ints))
  104. {
  105. int vdev;
  107. vdev = simple_strtoul(str, 0, 16);
  108. if (vdev >= 0 && vdev < 65536)
  109. tub3270_con_devno = vdev;
  110. return;
  111. }
  113. __initfunc (long tub3270_con_init(long kmem_start, long kmem_end))
  114. {
  115. tub3270_con_bcb.bc_len = 65536;
  116. if (!MACHINE_IS_VM && !MACHINE_IS_P390)
  117. return kmem_start;
  118. tub3270_con_bcb.bc_buf = (void *)kmem_start;
  119. kmem_start += tub3270_con_bcb.bc_len;
  120. register_console(&tub3270_con);
  121. return kmem_start;
  122. }
  123. #else
  124. #define tub3270_con_devno console_device
  126. void __init tub3270_con_init(void)
  127. {
  128. tub3270_con_bcb.bc_len = 65536;
  129. if (!CONSOLE_IS_3270)
  130. return;
  131. tub3270_con_bcb.bc_buf = (void *)alloc_bootmem_low(
  132. tub3270_con_bcb.bc_len);
  133. register_console(&tub3270_con);
  134. }
  135. #endif
  137. static kdev_t
  138. tub3270_con_device(struct console *conp)
  139. {
  140. return MKDEV(IBM_TTY3270_MAJOR, conp->index + 1);
  141. }
  143. static void
  144. tub3270_con_unblank(void)
  145. {
  146. /* flush everything:  panic has occurred */
  147. }
  149. int tub3270_con_write_deadlock_ct;
  150. int tub3270_con_write_deadlock_bytes;
  151. static void
  152. tub3270_con_write(struct console *conp,
  153. const char *buf, unsigned int count)
  154. {
  155. long flags;
  156. tub_t *tubp = tub3270_con_tubp;
  157. void tty3270_sched_bh(tub_t *);
  158. int rc;
  159. bcb_t obcb;
  161. obcb.bc_buf = (char *)buf;
  162. obcb.bc_len = obcb.bc_cnt = obcb.bc_wr =
  163. MIN(count, tub3270_con_bcb.bc_len);
  164. obcb.bc_rd = 0;
  166. spin_lock_irqsave(&tub3270_con_bcblock, flags);
  167. rc = tub3270_movedata(&obcb, &tub3270_con_bcb, 0);
  168. spin_unlock_irqrestore(&tub3270_con_bcblock, flags);
  170. if (tubp && rc && TUBTRYLOCK(tubp->irq, flags)) {
  171. tty3270_sched_bh(tubp);
  172. TUBUNLOCK(tubp->irq, flags);
  173. }
  174. }
  176. int tub3270_con_copy(tub_t *tubp)
  177. {
  178. long flags;
  179. int rc;
  181. spin_lock_irqsave(&tub3270_con_bcblock, flags);
  182. rc = tub3270_movedata(&tub3270_con_bcb, &tubp->tty_bcb, 0);
  183. spin_unlock_irqrestore(&tub3270_con_bcblock, flags);
  184. return rc;
  185. }
  186. #endif /* CONFIG_TN3270_CONSOLE */
  187. #else /* If generated as a MODULE */
  188. /*
  189.  * module init:  find tubes; get a major nbr
  190.  */
  191. int
  192. init_module(void)
  193. {
  194. if (tubnummins != 0) {
  195. printk(KERN_ERR "EEEK!!  Tube driver cobbigling!!n");
  196. return -1;
  197. }
  198. return tub3270_init();
  199. }
  201. /*
  202.  * remove driver:  unregister the major number
  203.  */
  204. void
  205. cleanup_module(void)
  206. {
  207. fs3270_fini();
  208. tty3270_fini();
  209. tubfiniminors();
  210. }
  211. #endif /* Not a MODULE or a MODULE */
  213. void
  214. tub_inc_use_count(void)
  215. {
  216. MOD_INC_USE_COUNT;
  217. }
  219. void
  220. tub_dec_use_count(void)
  221. {
  222. MOD_DEC_USE_COUNT;
  223. }
  225. static int
  226. tub3270_is_ours(s390_dev_info_t *dp)
  227. {
  228. if ((dp->sid_data.cu_type & 0xfff0) == 0x3270)
  229. return 1;
  230. if (dp->sid_data.cu_type == 0x3174)
  231. return 1;
  232. return 0;
  233. }
  235. /*
  236.  * tub3270_init() called by kernel or module initialization
  237.  */
  238. int
  239. tub3270_init(void)
  240. {
  241. s390_dev_info_t d;
  242. int i, rc;
  244. /*
  245.  * Copy and correct ebcdic - ascii translate tables
  246.  */
  247. memcpy(tub_ascebc, _ascebc, sizeof tub_ascebc);
  248. memcpy(tub_ebcasc, _ebcasc, sizeof tub_ebcasc);
  249. if (tubxcorrect) {
  250. /* correct brackets and circumflex */
  251. tub_ascebc['['] = 0xad;
  252. tub_ascebc[']'] = 0xbd;
  253. tub_ebcasc[0xad] = '[';
  254. tub_ebcasc[0xbd] = ']';
  255. tub_ascebc['^'] = 0xb0;
  256. tub_ebcasc[0x5f] = '^';
  257. }
  259. rc = tubinitminors();
  260. if (rc != 0)
  261. return rc;
  263. if (fs3270_init() || tty3270_init()) {
  264. printk(KERN_ERR "fs3270_init() or tty3270_init() failedn");
  265. fs3270_fini();
  266. tty3270_fini();
  267. tubfiniminors();
  268. return -1;
  269. }
  271. for (i = get_irq_first(); i >= 0; i = get_irq_next(i)) {
  272. if ((rc = get_dev_info_by_irq(i, &d)))
  273. continue;
  274. if (d.status)
  275. continue;
  277. #ifdef CONFIG_TN3270_CONSOLE
  278. #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0))
  279. if (d.sid_data.cu_type == 0x3215 && MACHINE_IS_VM) {
  280. cpcmd("TERM CONMODE 3270", NULL, 0);
  281. d.sid_data.cu_type = 0x3270;
  282. }
  283. #else
  284. if (d.sid_data.cu_type == 0x3215 && CONSOLE_IS_3270) {
  285. cpcmd("TERM CONMODE 3270", NULL, 0);
  286. d.sid_data.cu_type = 0x3270;
  287. }
  288. #endif /* LINUX_VERSION_CODE */
  289. #endif /* CONFIG_TN3270_CONSOLE */
  290. if (!tub3270_is_ours(&d))
  291. continue;
  293. rc = tubmakemin(i, &d);
  294. if (rc < 0) {
  295. printk(KERN_WARNING 
  296.        "3270 tube registration ran out of memory"
  297.        " after %d devicesn", tubnummins - 1);
  298. break;
  299. } else {
  300. printk(KERN_INFO "3270: %.4x on sch %d, minor %dn",
  301. d.devno, d.irq, rc);
  302. }
  303. }
  305. return 0;
  306. }
  308. /*
  309.  * tub3270_movedata(bcb_t *, bcb_t *) -- Move data stream
  310.  */
  311. int
  312. tub3270_movedata(bcb_t *ib, bcb_t *ob, int fromuser)
  313. {
  314. int count; /* Total move length */
  315. int rc;
  317. rc = count = MIN(ib->bc_cnt, ob->bc_len - ob->bc_cnt);
  318. while (count > 0) {
  319. int len1; /* Contig bytes avail in ib */
  321. if (ib->bc_wr > ib->bc_rd)
  322. len1 = ib->bc_wr - ib->bc_rd;
  323. else
  324. len1 = ib->bc_len - ib->bc_rd;
  325. if (len1 > count)
  326. len1 = count;
  328. while (len1 > 0) {
  329. int len2; /* Contig space avail in ob */
  331. if (ob->bc_rd > ob->bc_wr)
  332. len2 = ob->bc_rd - ob->bc_wr;
  333. else
  334. len2 = ob->bc_len - ob->bc_wr;
  335. if (len2 > len1)
  336. len2 = len1;
  338. if (fromuser) {
  339. len2 -= copy_from_user(ob->bc_buf + ob->bc_wr,
  340.        ib->bc_buf + ib->bc_rd,
  341.        len2);
  342. if (len2 == 0) {
  343. if (!rc)
  344. rc = -EFAULT;
  345. break;
  346. }
  347. } else
  348. memcpy(ob->bc_buf + ob->bc_wr,
  349.        ib->bc_buf + ib->bc_rd,
  350.        len2);
  352. ib->bc_rd += len2;
  353. if (ib->bc_rd == ib->bc_len)
  354. ib->bc_rd = 0;
  355. ib->bc_cnt -= len2;
  357. ob->bc_wr += len2;
  358. if (ob->bc_wr == ob->bc_len)
  359. ob->bc_wr = 0;
  360. ob->bc_cnt += len2;
  362. len1 -= len2;
  363. count -= len2;
  364. }
  365. }
  366. return rc;
  367. }
  369. /*
  370.  * receive an interrupt
  371.  */
  372. void
  373. tubint(int irq, void *ipp, struct pt_regs *prp)
  374. {
  375. devstat_t *dsp = ipp;
  376. tub_t *tubp;
  378. if ((tubp = IRQ2TUB(irq)) && (tubp->intv))
  379. (tubp->intv)(tubp, dsp);
  380. }
  382. /*
  383.  * Initialize array of pointers to minor structures tub_t.
  384.  * Returns 0 or -ENOMEM.
  385.  */
  386. int
  387. tubinitminors(void)
  388. {
  389. tubminors = (tub_t *(*)[TUBMAXMINS])kmalloc(sizeof *tubminors,
  390. GFP_KERNEL);
  391. if (tubminors == NULL)
  392. return -ENOMEM;
  393. memset(tubminors, 0, sizeof *tubminors);
  394. return 0;
  395. }
  397. /*
  398.  * Add a minor 327x device.  Argument is an irq value.
  399.  *
  400.  * Point elements of two arrays to the newly created tub_t:
  401.  * 1. (*tubminors)[minor]
  402.  * 2. (*(*tubirqs)[irqhi])[irqlo]
  403.  * The first looks up from minor number at context time; the second
  404.  * looks up from irq at interrupt time.
  405.  */
  406. int
  407. #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0))
  408. tubmakemin(int irq, dev_info_t *dp)
  409. #else
  410. tubmakemin(int irq, s390_dev_info_t *dp)
  411. #endif
  412. {
  413. tub_t *tubp;
  414. int minor;
  415. long flags;
  417. if ((minor = ++tubnummins) == TUBMAXMINS)
  418. return -ENODEV;
  420. tubp = kmalloc(sizeof(tub_t), GFP_KERNEL);
  421. if (tubp == NULL) {
  422. return -ENOMEM;
  423. }
  424. if (tubaddbyirq(tubp, irq) != 0) {
  425. kfree(tubp);
  426. return -ENOMEM;
  427. }
  428. memset(tubp, 0, sizeof(tub_t));
  429. tubp->minor = minor;
  430. tubp->irq = irq;
  431. TUBLOCK(tubp->irq, flags);
  432. tubp->devno = dp->devno;
  433. tubp->geom_rows = _GEOM_ROWS;
  434. tubp->geom_cols = _GEOM_COLS;
  435. init_waitqueue_head(&tubp->waitq);
  437. tubp->tty_bcb.bc_len = TTY_OUTPUT_SIZE;
  438. tubp->tty_bcb.bc_buf = (void *)kmalloc(tubp->tty_bcb.bc_len,
  439. GFP_KERNEL|GFP_DMA);
  440. if (tubp->tty_bcb.bc_buf == NULL) {
  441. TUBUNLOCK(tubp->irq, flags);
  442. tubdelbyirq(tubp, irq);
  443. kfree(tubp);
  444. return -ENOMEM;
  445. }
  446. tubp->tty_bcb.bc_cnt = 0;
  447. tubp->tty_bcb.bc_wr = 0;
  448. tubp->tty_bcb.bc_rd = 0;
  449. (*tubminors)[minor] = tubp;
  451. #ifdef CONFIG_TN3270_CONSOLE
  452. if (CONSOLE_IS_3270) {
  453. if (tub3270_con_tubp == NULL && 
  454.     tub3270_con_bcb.bc_buf != NULL &&
  455.     (tub3270_con_devno == -1 ||
  456.      tub3270_con_devno == dp->devno)) {
  457. extern void tty3270_int(tub_t *, devstat_t *);
  459. tub3270_con_devno = dp->devno;
  460. tubp->cmd = TBC_CONOPEN;
  461. tubp->flags |= TUB_OPEN_STET | TUB_INPUT_HACK;
  462. tty3270_size(tubp, &flags);
  463. tubp->tty_input = kmalloc(GEOM_INPLEN,
  464. GFP_KERNEL|GFP_DMA);
  465. tty3270_aid_init(tubp);
  466. tty3270_scl_init(tubp);
  467. tub3270_con_irq = tubp->irq;
  468. tub3270_con_tubp = tubp;
  469. tubp->intv = tty3270_int;
  470. tubp->cmd = TBC_UPDSTAT;
  471. tty3270_build(tubp);
  472. }
  473. }
  474. #endif /* CONFIG_TN3270_CONSOLE */
  476. #ifdef CONFIG_DEVFS_FS
  477. fs3270_devfs_register(tubp);
  478. #endif
  480. TUBUNLOCK(tubp->irq, flags);
  481. return minor;
  482. }
  484. /*
  485.  * Release array of pointers to minor structures tub_t, but first
  486.  * release any storage pointed to by them.
  487.  */
  488. void
  489. tubfiniminors(void)
  490. {
  491. int i;
  492. tub_t **tubpp, *tubp;
  494. if (tubminors == NULL)
  495. return;
  497. for (i = 0; i < TUBMAXMINS; i++) {
  498. tubpp = &(*tubminors)[i];
  499. if ((tubp = *tubpp)) {
  500. #ifdef CONFIG_DEVFS_FS
  501. fs3270_devfs_unregister(tubp);
  502. #endif
  503. tubdelbyirq(tubp, tubp->irq);
  504. tty3270_rcl_fini(tubp);
  505. kfree(tubp->tty_bcb.bc_buf);
  506. if (tubp->tty_input) {
  507. kfree(tubp->tty_input);
  508. tubp->tty_input = NULL;
  509. }
  510. tubp->tty_bcb.bc_buf = NULL;
  511. tubp->ttyscreen = NULL;
  512. kfree(tubp);
  513. *tubpp = NULL;
  514. }
  515. }
  516. kfree(tubminors);
  517. tubminors = NULL;
  518. tubfiniirqs();
  519. }
  521. /*
  522.  * tubaddbyirq() -- Add tub_t for irq lookup in tubint()
  523.  */
  524. int
  525. tubaddbyirq(tub_t *tubp, int irq)
  526. {
  527. int irqhi = (irq >> 8) & 255;
  528. int irqlo = irq & 255;
  529. tub_t *(*itubpp)[256];
  531. /* Allocate array (*tubirqs)[] if first time */
  532. if (tubirqs == NULL) {
  533. tubirqs = (tub_t *(*(*)[256])[256])
  534. kmalloc(sizeof *tubirqs, GFP_KERNEL);
  535. if (tubirqs == NULL)
  536. return -ENOMEM;
  537. memset(tubirqs, 0, sizeof *tubirqs);
  538. }
  540. /* Allocate subarray (*(*tubirqs)[])[] if first use */
  541. if ((itubpp = (*tubirqs)[irqhi]) == NULL) {
  542. itubpp = (tub_t *(*)[256])
  543. kmalloc(sizeof(*itubpp), GFP_KERNEL);
  544. if (itubpp == NULL) {
  545. if (tubnummins == 1) {  /* if first time */
  546. kfree(tubirqs);
  547. tubirqs = NULL;
  548. }
  549. return -ENOMEM;
  550. } else {
  551. memset(itubpp, 0, sizeof(*itubpp));
  552. (*tubirqs)[irqhi] = itubpp;
  553. }
  554. }
  556. /* Request interrupt service */
  557. if ((tubp->irqrc = request_irq(irq, tubint, SA_INTERRUPT,
  558.     "3270 tube driver", &tubp->devstat)) != 0)
  559. return tubp->irqrc;
  561. /* Fill in the proper subarray element */
  562. (*itubpp)[irqlo] = tubp;
  563. return 0;
  564. }
  566. /*
  567.  * tubfindbyirq(irq)
  568.  */
  569. tub_t *
  570. tubfindbyirq(int irq)
  571. {
  572. int irqhi = (irq >> 8) & 255;
  573. int irqlo = irq & 255;
  574. tub_t *tubp;
  576. if (tubirqs == NULL)
  577. return NULL;
  578. if ((*tubirqs)[irqhi] == NULL)
  579. return NULL;
  580. tubp = (*(*tubirqs)[irqhi])[irqlo];
  581. if (tubp->irq == irq)
  582. return tubp;
  583. return NULL;
  584. }
  586. /*
  587.  * tubdelbyirq(tub_t*, irq)
  588.  */
  589. void
  590. tubdelbyirq(tub_t *tubp, int irq)
  591. {
  592. int irqhi = (irq >> 8) & 255;
  593. int irqlo = irq & 255;
  594. tub_t *(*itubpp)[256], *itubp;
  596. if (tubirqs == NULL) {
  597. printk(KERN_ERR "tubirqs is NULLn");
  598. return;
  599. }
  600. itubpp = (*tubirqs)[irqhi];
  601. if (itubpp == NULL) {
  602. printk(KERN_ERR "tubirqs[%d] is NULLn", irqhi);
  603. return;
  604. }
  605. itubp = (*itubpp)[irqlo];
  606. if (itubp == NULL) {
  607. printk(KERN_ERR "tubirqs[%d][%d] is NULLn", irqhi, irqlo);
  608. return;
  609. }
  610. if (itubp->irqrc == 0)
  611. free_irq(irq, &itubp->devstat);
  612. (*itubpp)[irqlo] = NULL;
  613. }
  615. /*
  616.  * tubfiniirqs() -- clean up storage in tub_t *(*(*tubirqs)[256])[256]
  617.  */
  618. void
  619. tubfiniirqs(void)
  620. {
  621. int i;
  622. tub_t *(*itubpp)[256];
  624. if (tubirqs != NULL) {
  625. for (i = 0; i < 256; i++) {
  626. if ((itubpp = (*tubirqs)[i])) {
  627. kfree(itubpp);
  628. (*tubirqs)[i] = NULL;
  629. }
  630. }
  631. kfree(tubirqs);
  632. tubirqs = NULL;
  633. }
  634. }