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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > TCP/IP协议栈 > 查看源码
pi.c
资源名称：export.zip　[点击查看]
上传用户：hepax88
上传日期：2007-01-03
资源大小：1101k
文件大小：37k
源码类别：

TCP/IP协议栈

开发平台：

Visual C++

pi.c：源码内容
  1. /*
  2.  * Interface driver for the VE3IFB 8530 card (PI card)
  3.  * Copyright 1990 by Dave Perry, VE3IFB
  4.  * Minor delinting - KA9Q 2/2/91
  5.  *
  6.  * Portions of this driver were derived from the Eagle card
  7.  * driver by Art Goldman, WA3CVG. It has been very extensively
  8.  * modified from his work, due to the addition of DMA support
  9.  * and due to differences in the hardware.  The PI card is NOT
  10.  * an Eagle card clone. It is an original design by Dave Perry,
  11.  * VE3IFB.  Art's copyright notice follows:
  12.  *
  13.  *  Written by Art Goldman, WA3CVG - (c) Copyright 1987 All Rights Reserved
  14.  *  Permission for non-commercial use is hereby granted provided this notice
  15.  *  is retained.  For info call: (301) 997-3838.
  16.  *
  17.  */
  19. #include <time.h>
  20. #include <stdio.h>
  21. #include <dos.h>
  22. #include <bios.h>
  23. #include "global.h"
  24. #include "mbuf.h"
  25. #include "iface.h"
  26. #include "pktdrvr.h"
  27. #include "netuser.h"
  28. #include "pi.h"
  29. #include "z8530.h"
  30. #include "ax25.h"
  31. #include "trace.h"
  32. #include "nospc.h"
  34. #include "session.h"
  35. #include "lapb.h"
  36. #include "proc.h"
  37. #include "ip.h"
  38. #include "devparam.h"
  40. #ifndef FP_OFF
  41. #define FP_OFF(fp) ((unsigned)(fp))
  42. #endif
  43. #ifndef FP_SEG
  44. #define FP_SEG(fp) ((unsigned)((unsigned long)(fp) >> 16))
  45. #endif
  47. void b_rxint(struct pichan *);
  48. void b_txint(struct pichan *);
  49. void b_exint(struct pichan *);
  50. void a_rxint(struct pichan *);
  51. void a_txint(struct pichan *);
  52. void a_exint(struct pichan *);
  54. static void xwrite_scc(struct pichan *hp,uint16 ctl,uint16 reg,
  55. uint16 val );
  56. static char xread_scc(struct pichan *hp, uint16 ctl, char reg);
  57. static int32 pi_ctl(struct iface *iface,int cmd,int set,int32 val);
  58. static int pi_raw(struct iface *iface,struct mbuf **bpp);
  59. static int pi_stop(struct iface *iface);
  60. static void rts(struct pichan *hp, uint16 x);
  61. void setup_rx_dma(struct pichan *hp);
  62. void setup_tx_dma(struct pichan *hp);
  63. static void set_acc_delay(void);
  64. static void tdelay(register struct pichan *hp,unsigned int time);
  65. static int scc_init(register struct pichan *hp);
  67. static struct PITAB Pi[PIMAX]; /* Device table - one entry per card */
  68. static INTERRUPT (*pihandle[])() = { /* handler interrupt vector table */
  69. pi0vec,
  70. pi1vec,
  71. pi2vec
  72. };
  73. static uint16 Page_regs[] = {
  74. 0x87,0x83,0x81,0x82,0,0x8b,0x89,0x8a
  75. };
  76. static struct pichan Pichan[2*PIMAX]; /* channel table - 2 entries per card */
  77. static uint16 pinbr;
  79. extern uint16 acc_delay; /* Delay for the 8530 chip access recovery time */
  82. /* This calculates the constant to be used in the delay loops
  83.  *  which satify the SCC's access recovery time.  It needs to be timed and
  84.  *  calculated because a fixed value would not work in a 4.77mhz XT
  85.  *  to a 40mhz 486 (and beyond).
  86.  */
  87. static void
  88. set_acc_delay()
  89. {
  90. long starttime, endtime;
  91. int n;
  92. int ticks;
  94. starttime = bioscnt();
  95. for(n = 0; n < 10; n++)
  96. mloop();
  97. endtime = bioscnt();
  98. ticks = (int) (endtime - starttime);
  99. if(ticks == 0)
  100. ticks = 1;
  101. acc_delay = 61/ticks;
  102. if(acc_delay == 0)
  103. acc_delay = 1;
  104. fflush(stdout);
  105. }
  107. /* Write 8530 register */
  108. static void
  109. xwrite_scc(hp,ctl,reg,val)
  110. register struct pichan *hp;
  111. register uint16 ctl;
  112. uint16 reg,val;
  113. {
  114. wrtscc(hp->cardbase,ctl,reg,val);
  115. }
  117. /* Read 8530 register */
  118. static char
  119. xread_scc(hp,ctl,reg)
  120. register struct pichan *hp;
  121. register uint16 ctl;
  122. char reg;
  123. {
  124. return(rdscc(hp->cardbase,ctl,reg));
  125. }
  127. /* Setup 8253 chip for time delay */
  128. static void
  129. tdelay(hp,time)
  130. register struct pichan *hp;
  131. unsigned int time;  /* Time to delay in milliseconds */
  132. {
  133. int n,port;
  134. unsigned int t1;
  135. unsigned char sc;
  137. if(hp->base & 2){ /* If A channel */
  138. sc = SC1;
  139. t1 = time;
  140. port = hp->cardbase+TMR1;
  141. } else {
  142. sc = SC2;
  143. t1 = 10 * time; /* 10s of milliseconds for the B channel */
  144. port = hp->cardbase+TMR2;
  145. }
  147. /* Setup timer sc */
  148. outportb(hp->cardbase+TMRCMD, sc|LSB_MSB|MODE0);
  150. /* satisfy access time restriction */
  151. for(n=0; n<5;n++)
  152. ;
  153. /* times 2 to make millisecs */
  154. outportb(port, (t1 << 1) & 0xFF);
  156. /* satisfy access time restriction */
  157. for(n=0; n<5;n++)
  158. ;
  159. outportb(port, (t1 >> 7) & 0xFF);
  161. /* Enable correct int for timeout */
  162. xwrite_scc(hp,hp->base+CTL,R15,CTSIE);
  163. xwrite_scc(hp,hp->base+CTL,R1,EXT_INT_ENAB);
  164. xwrite_scc(hp,hp->base+CTL,R0,RES_EXT_INT);
  165. }
  167. /* Master interrupt handler.  One interrupt at a time is handled.
  168.  * here. Service routines are called from here.
  169.  */
  170. INTERRUPT (far *(piint)(dev))()
  171. int dev;
  172. {
  173. register char st;
  174. register uint16 pcbase;
  175. struct pichan *hp;
  176. struct PITAB *pip;
  178. pip = &Pi[dev];
  179. pip->ints++;
  180. pcbase = pip->addr;
  182. /* Read interrupt status register (only valid from channel A)
  183.  * Process all pending interrupts in while loop
  184.  */
  185. hp = &Pichan[2 * dev]; /* Assume channel A */
  186. while((st = xread_scc(hp,pcbase+CHANA+CTL,R3)) != 0){
  187. if(st & CHARxIP){
  188. /* Channel A Rcv Interrupt Pending */
  189. hp = &Pichan[2 * dev];
  190. a_rxint(hp);
  191. } else if(st & CHATxIP){
  192. /* Channel A Transmit Int Pending */
  193. hp = &Pichan[2 * dev];
  194. a_txint(hp);
  195. } else if(st & CHAEXT){
  196. /* Channel A External Status Int */
  197. hp = &Pichan[2 * dev];
  198. a_exint(hp);
  199. } else if(st & CHBRxIP){
  200. /* Channel B Rcv Interrupt Pending */
  201. hp = &Pichan[(2 * dev)+1];
  202. b_rxint(hp);
  203. } else if(st & CHBTxIP){
  204. /* Channel B Transmit Int Pending */
  205. hp = &Pichan[(2 * dev)+1];
  206. b_txint(hp);
  207. } else if(st & CHBEXT){
  208. /* Channel B External Status Int */
  209. hp = &Pichan[(2 * dev)+1];
  210. b_exint(hp);
  211. }
  212. /* Reset highest interrupt under service */
  213. xwrite_scc(hp,hp->base+CTL,R0,RES_H_IUS);
  214. } /* End of while loop on int processing */
  215. return pip->chain ? pip->oldvec : NULL;
  216. }
  218. static void
  219. a_exint(hp)
  220. register struct pichan *hp;
  221. {
  222. register uint16 cmd;
  223. char st;
  224. int32 t,ca;
  225. struct mbuf *bp;
  226. int i_state;
  228. i_state = dirps();
  230. st = xread_scc(hp,hp->base+CTL,R0);     /* Fetch status */
  232. /* reset external status latch */
  233. xwrite_scc(hp,CTL+hp->base,R0,RES_EXT_INT);
  234. cmd = hp->base+CTL;
  235. hp->exints++;
  237. if((hp->rstate >= ACTIVE) && (st & BRK_ABRT)){
  238. setup_rx_dma(hp);
  239. hp->rstate = ACTIVE;
  240. }
  241. switch(hp->tstate){
  242. case ACTIVE:
  243. hp->tstate = FLAGOUT;
  244. tdelay(hp,hp->squeldelay);
  245. break;
  246. case FLAGOUT:
  247. if((bp = dequeue(&hp->sndq)) == NULL){
  248. /* Nothing to send - return to receive mode */
  249. hp->tstate = IDLE;
  250. rts(hp,OFF);
  251. restore(i_state);
  252. return;
  253. }
  254. /* Get all chars */
  255. hp->txcnt = pullup(&bp,hp->sndbuf,hp->bufsiz);
  256. free_p(&bp); /* Truncate overly long packets */
  258. /* NOTE - fall through if more to send */
  259. case ST_TXDELAY:
  260. /* Disable DMA chan */
  261. outportb(DMA_MASK, DMA_DISABLE|hp->dmachan);
  263. /* Set up for TX dma */
  264. xwrite_scc(hp,cmd,R1,WT_FN_RDYFN|EXT_INT_ENAB);
  266. /* Setup DMA controller for tx */
  267. setup_tx_dma(hp);
  269. /* select transmit interrupts to enable */
  270. /* Allow DMA on chan */
  271. outportb(DMA_MASK,DMA_ENABLE|hp->dmachan);
  273. /* reset CRC, Txint pend*/
  274. xwrite_scc(hp,cmd,R0,RES_Tx_CRC|RES_Tx_P);
  276. /* allow Underrun int only */
  277. xwrite_scc(hp,cmd,R15,TxUIE);
  279. /* Enable TX DMA */
  280. xwrite_scc(hp,cmd,R1,WT_RDY_ENAB|WT_FN_RDYFN|EXT_INT_ENAB);
  282. /* Send CRC on underrun */
  283. xwrite_scc(hp,cmd,R0,RES_EOM_L);
  285. /* packet going out now */
  286. hp->tstate = ACTIVE;
  287. break;
  288. case DEFER:
  289. /* we have deferred prev xmit attempt
  290.  * See Intel Microcommunications Handbook, p2-308
  291.  */
  292. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  293. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  294. if((xread_scc(hp,cmd,R0) & DCD) != 0){
  295. hp->tstate = DEFER;
  296. tdelay(hp,100);
  297. /* Defer until dcd transition or 100mS timeout */
  298. xwrite_scc(hp,CTL+hp->base,R15,CTSIE|DCDIE);
  299. restore(i_state);
  300. return;
  301. }
  302. /* Defer logic. Wait until deftime is in the past (so we
  303.  * defer to any overheard CTS messages) AND the p-persistence
  304.  * dice roll succeeds. The computation of ca allows for clock
  305.  * rollover (which happens every 49+ days).
  306.  */
  307. t = msclock();
  308. ca = hp->deftime - t;
  309. if(ca > 0){
  310. hp->tstate = DEFER;
  311. tdelay(hp,ca);
  312. restore(i_state);
  313. return;
  314. }
  315. hp->deftime = t; /* Keep from getting too old */
  316. if((rand() & 0xff) > hp->persist){
  317. hp->tstate = DEFER;
  318. tdelay(hp,hp->slotime);
  319. restore(i_state);
  320. return;
  321. }
  322. /* Assert RTS early minimize collision window */
  323. xwrite_scc(hp,cmd,R5,TxCRC_ENAB|RTS|Tx8);
  324. rts(hp,ON); /* Transmitter on */
  325. hp->tstate = ST_TXDELAY;
  326. tdelay(hp,hp->txdelay);
  327. restore(i_state);
  328. return;
  329. } /* switch(hp->tstate) */
  331. restore(i_state);
  332. } /* a_exint() */
  334. /* Receive interrupt handler for the A channel 
  335.  */
  336. static void
  337. a_rxint(hp)
  338. register struct pichan *hp;
  339. {
  340. register uint16 cmd;
  341. register uint16 bytecount;
  342. char rse;
  343. struct mbuf *bp;
  344. int i_state;
  346. hp->rxints++;
  347. cmd = hp->base+CTL;
  349. i_state = dirps();
  350. rse = xread_scc(hp,cmd,R1); /* Get special condition bits from R1 */
  351. if(rse & Rx_OVR){
  352. /* If receiver overrun */
  353. hp->rovers++;
  354. hp->rstate = RXERROR;
  355. }
  357. if(rse & END_FR){
  358. /* If end of frame */
  359. /* figure length of frame from 8237 */
  360. outportb(DMA_RESETFF,0); /* reset firstlast ff */
  361. bytecount = inportb(DMABASE+2*hp->dmachan+1);
  362. bytecount += inportb(DMABASE+2*hp->dmachan+1) << 8;
  363. bytecount = hp->bufsiz - 1 - bytecount;
  365. if((rse & CRC_ERR)||(hp->rstate > ACTIVE)||(bytecount < 10)){
  366. if((bytecount >= 10) && (rse & CRC_ERR))
  367. hp->crcerr++; /* Ignore noise */
  369. /* Reset buffer pointers */
  370. hp->rstate = ACTIVE;
  371. setup_rx_dma(hp);
  372. } else {
  373. /* Here we have a valid frame. Copy to buffer,
  374.  * minus 2 CRC bytes
  375.  */
  376. bytecount -= 2;
  377. if((bp = alloc_mbuf(bytecount+sizeof(struct iface *)))
  378.  != NULL){
  379. bp->data += sizeof(struct iface *);
  380. bp->cnt = bytecount;
  381. memcpy(bp->data,hp->rcvbuf,bytecount);
  382. net_route(hp->iface,&bp);
  383. hp->rxcnt = 0;
  384. hp->rxframes++;
  385. }
  386. /* packet queued - get buffer for next frame */
  387. setup_rx_dma(hp);
  388. } /* end good frame queued */
  389. } /* end EOF check */
  391. xwrite_scc(hp,hp->base+CTL,R0,ERR_RES); /* error reset */
  392. restore(i_state);
  393. }
  395. void
  396. a_txint(hp)
  397. register struct pichan *hp;
  398. {
  399. register uint16 cmd;
  400. int32 t,ca;
  401. struct mbuf *bp;
  402. int i_state;
  404. cmd = CTL+hp->base;
  406. i_state = dirps();
  407. switch(hp->tstate){
  408. case IDLE:
  409. /* Transmitter idle. Find a frame for transmission */
  410. if((bp = dequeue(&hp->sndq)) == NULL){
  411. rts(hp,OFF);
  412. restore(i_state);
  413. return;
  414. }
  415. /* If a buffer to send, we drop thru here */
  416. hp->txcnt = pullup(&bp,hp->sndbuf,hp->bufsiz);
  417. free_p(&bp); /* Truncate overly long packet */
  418. hp->tcp = hp->sndbuf;
  419. case DEFER:
  420. /* we may have deferred prev xmit attempt */
  421. /* Check DCD - debounce it
  422.  * See Intel Microcommunications Handbook, p2-308
  423.  */
  424. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  425. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  426. if((xread_scc(hp,cmd,R0) & DCD) != 0){
  427. hp->tstate = DEFER;
  428. tdelay(hp,100);
  429. /* defer until DCD transition or timeout */
  430. xwrite_scc(hp,cmd,R15,CTSIE|DCDIE);
  431. restore(i_state);
  432. return;
  433. }
  434. /* Defer logic. Wait until deftime is in the past (so we
  435.  * defer to any overheard CTS messages) AND the p-persistence
  436.  * dice roll succeeds. The computation of ca allows for clock
  437.  * rollover (which happens every 49+ days).
  438.  */
  439. t = msclock();
  440. ca = hp->deftime - t;
  441. if(ca > 0){
  442. hp->tstate = DEFER;
  443. tdelay(hp,ca);
  444. restore(i_state);
  445. return;
  446. }
  447. hp->deftime = t; /* Keep from getting too old */
  448. if((rand() & 0xff) > hp->persist){
  449. hp->tstate = DEFER;
  450. tdelay(hp,hp->slotime);
  451. restore(i_state);
  452. return;
  453. }
  455. /* Assert RTS early minimize collision window */
  456. xwrite_scc(hp,cmd,R5,TxCRC_ENAB|RTS|Tx8);
  457. rts(hp,ON); /* Transmitter on */
  458. hp->tstate = ST_TXDELAY;
  459. tdelay(hp,hp->txdelay);
  460. restore(i_state);
  461. return;
  462. default:
  463. break;
  464. } /* end switch(hp->state) */
  466. restore(i_state);
  467. } /*a_txint */
  469. static void
  470. b_rxint(hp)
  471. register struct pichan *hp;
  472. {
  473. register uint16 cmd;
  474. char rse;
  475. struct mbuf *bp;
  476. int i_state;
  478. hp->rxints++;
  479. cmd = CTL+hp->base;
  481. i_state = dirps();
  482. if((xread_scc(hp,cmd,R0)) & Rx_CH_AV){
  483. /* there is a char to be stored
  484.  * read special condition bits before reading the data char
  485.  */
  486. rse = xread_scc(hp,cmd,R1); /* get status byte from R1 */
  487. if(rse & Rx_OVR){
  488. /* Rx overrun - toss buffer */
  489. /* reset buffer pointers */
  490. hp->rcp = hp->rcvbuf;
  491. hp->rxcnt = 0;
  492. hp->rstate = RXERROR; /* set error flag */
  493. hp->rovers++;
  494. } else if(hp->rxcnt >= hp->bufsiz){
  495. /* Too large -- toss entire frame */
  496. /* reset buffer pointers */
  497. hp->rcp = hp->rcvbuf;
  498. hp->rxcnt = 0;
  499. hp->rstate = TOOBIG; /* when set, chars are not stored */
  500. }
  501. /* ok, we can store the received character now */
  502. if(hp->rstate == ACTIVE){ /* If no errors... */
  503. *hp->rcp++ = xread_scc(hp,cmd,R8); /* char to rcv buff */
  504. hp->rxcnt++;    /* bump count */
  505. } else {
  506. /* got to empty FIFO */
  507. (void) xread_scc(hp,cmd,R8);
  508. xwrite_scc(hp,cmd,R0,ERR_RES); /* reset err latch */
  509. hp->rstate = ACTIVE;
  510. }
  511. }
  513. if(rse & END_FR){
  514. /* END OF FRAME -- Make sure Rx was active */
  515. if(hp->rxcnt > 0){
  516. if((rse & CRC_ERR)||(hp->rstate > ACTIVE)||(hp->rxcnt < 10)){
  517. if((hp->rxcnt >= 10) && (rse & CRC_ERR))
  518. hp->crcerr++; /* Ignore noise */
  520. hp->rcp = hp->rcvbuf;
  521. hp->rxcnt = 0;
  522. } else {
  523. /* Here we have a valid frame */
  524. hp->rxcnt -= 2;  /* Toss 2 crc bytes */
  525. if((bp = alloc_mbuf(hp->rxcnt+sizeof(struct iface *)))
  526.  != NULL){
  527. bp->data += sizeof(struct iface *);
  528. bp->cnt = hp->rxcnt;
  529. memcpy(bp->data,hp->rcvbuf,hp->rxcnt);
  530. net_route(hp->iface,&bp);
  531. hp->rxframes++;
  532. }
  533. /* packet queued - get ready for next frame */
  534. hp->rcp = hp->rcvbuf;
  535. hp->rxcnt = 0;
  536. } /* end good frame queued */
  537. }  /* end check for active receive upon EOF */
  538. hp->rstate = ACTIVE; /* and clear error status */
  539. } /* end EOF check */
  541. restore(i_state);
  542. }
  544. static void
  545. b_txint(hp)
  546. register struct pichan *hp;
  547. {
  548. register uint16 cmd;
  549. char c;
  550. struct mbuf *bp;
  551. int i_state;
  553. cmd = CTL+hp->base;
  555. i_state = dirps();
  556. if(hp->tstate != DEFER && hp->tstate)
  557. hp->txints++;
  559. switch(hp->tstate){
  560. case CRCOUT:
  561. hp->tstate = FLAGOUT;
  562. tdelay(hp,hp->squeldelay);
  563. restore(i_state);
  564. return;
  565. case IDLE:
  566. /* Transmitter idle. Find a frame for transmission */
  567. if((bp = dequeue(&hp->sndq)) == NULL){
  568. /* Nothing to send - return to receive mode
  569.  * Tx OFF now - flag should have gone
  570.  */
  571. rts(hp,OFF);
  572. restore(i_state);
  573. return;
  574. }
  575. hp->txcnt = pullup(&bp,hp->sndbuf,hp->bufsiz);
  576. free_p(&bp); /* Truncate overly long packets */
  577. /* If a buffer to send, we drop thru here */
  578. case DEFER:     /* we may have deferred prev xmit attempt */
  579. /* Check DCD - debounce it */
  580. /* See Intel Microcommunications Handbook, p2-308 */
  581. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  582. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  583. if((xread_scc(hp,cmd,R0) & DCD) != 0){
  584. hp->tstate = DEFER;
  585. tdelay(hp,100);
  586. /* defer until DCD transition or timeout */
  587. xwrite_scc(hp,cmd,R15,CTSIE|DCDIE);
  588. restore(i_state);
  589. return;
  590. }
  591. /* p - persist calculation */
  592. if(inportb(hp->cardbase+TMR0) > hp->persist){
  593. inportb(hp->cardbase+TMR0); /* Discard MSB */
  594. hp->tstate = DEFER;
  595. tdelay(hp,hp->slotime);
  596. restore(i_state);
  597. return;
  598. }
  599. inportb(hp->cardbase+TMR0); /* Discard MSB */
  601. rts(hp,ON);   /* Transmitter on */
  602. hp->tstate = ST_TXDELAY;
  603. tdelay(hp,hp->txdelay);
  604. restore(i_state);
  605. return;
  607. case ACTIVE:
  608. /* Here we are actively sending a frame */
  609. if(hp->txcnt-- != 0){
  610. c = *hp->tcp++;
  611. /* next char is gone */
  612. xwrite_scc(hp,cmd,R8,c);
  613. /* stuffing a char satisfies Interrupt condition */
  614. } else {
  615. /* No more to send */
  616. if((xread_scc(hp,cmd,R0) & 0x40)){
  617. /* Did we underrun? */
  618. /* unexpected underrun */
  619. hp->tunders++;
  620. xwrite_scc(hp,cmd,R0,SEND_ABORT);
  621. hp->tstate = FLAGOUT;
  622. tdelay(hp,hp->squeldelay);
  623. restore(i_state);
  624. return;
  625. }
  626. hp->tstate = UNDERRUN; /* Now we expect to underrun */
  627. /* Send flags on underrun */
  628. if(hp->speed){ /* If externally clocked */
  629. xwrite_scc(hp,cmd,R10,CRCPS|NRZI);
  630. } else {
  631. xwrite_scc(hp,cmd,R10,CRCPS);
  632. }
  633. xwrite_scc(hp,cmd,R0,RES_Tx_P); /* reset Tx Int Pend */
  634. }
  635. restore(i_state);
  636. return;     /* back to wait for interrupt */
  637. } /* end switch */
  638. restore(i_state);
  639. }
  641. /* Pi SIO External/Status interrupts (for the B channel)
  642.  * This can be caused by a receiver abort, or a Tx UNDERRUN/EOM.
  643.  * Receiver automatically goes to Hunt on an abort.
  644.  *
  645.  * If the Tx Underrun interrupt hits, change state and
  646.  * issue a reset command for it, and return.
  647.  */
  648. static void
  649. b_exint(hp)
  650. register struct pichan *hp;
  651. {
  652. char st;
  653. register uint16 cmd;
  654. char c;
  655. struct mbuf *bp;
  656. int i_state;
  658. cmd = CTL+hp->base;
  659. hp->exints++;
  660. i_state = dirps();
  661. st = xread_scc(hp,cmd,R0);     /* Fetch status */
  662. /* reset external status latch */
  663. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  665. switch(hp->tstate){
  666. case ACTIVE: /* Unexpected underrun */
  667. xwrite_scc(hp,cmd,R0,SEND_ABORT);
  668. hp->tstate = FLAGOUT;
  669. hp->tunders++;
  670. tdelay(hp,hp->squeldelay);
  671. restore(i_state);
  672. return;
  673. case UNDERRUN:
  674. hp->tstate = CRCOUT;
  675. restore(i_state);
  676. return;
  677. case FLAGOUT: 
  678. /* Find a frame for transmission */
  679. if((bp = dequeue(&hp->sndq)) == NULL){
  680. /* Nothing to send - return to receive mode
  681.  * Tx OFF now - flag should have gone
  682.  */
  683. rts(hp,OFF);
  684. hp->tstate = IDLE;
  685. restore(i_state);
  686. return;
  687. }
  688. hp->txcnt = pullup(&bp,hp->sndbuf,hp->bufsiz);
  689.                 free_p(&bp); /* Truncate overly long packets */
  690. hp->tcp = hp->sndbuf;
  692. /* Get next char to send */
  693. c = *hp->tcp++;
  694. hp->txcnt--;
  695. xwrite_scc(hp,cmd,R0,RES_Tx_CRC);/* reset for next frame */
  697. /* Send abort on underrun */
  698. if(hp->speed){ /* If externally clocked */
  699. xwrite_scc(hp,cmd,R10,CRCPS|NRZI|ABUNDER);
  700. } else {
  701. xwrite_scc(hp,cmd,R10,CRCPS|ABUNDER);
  702. }
  704. xwrite_scc(hp,cmd,R8,c); /* First char out now */
  705. xwrite_scc(hp,cmd,R0,RES_EOM_L);/* Reset end of message latch */
  707. /* select transmit interrupts to enable */
  709. xwrite_scc(hp,cmd,R15,TxUIE); /* allow Underrun int only */
  710. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  711. xwrite_scc(hp,cmd,R1,TxINT_ENAB|EXT_INT_ENAB);  /* Tx/Extern ints on */
  713. hp->tstate = ACTIVE; /* char going out now */
  714. restore(i_state);
  715. return;
  717. case DEFER:
  718. /* Check DCD - debounce it
  719.  * See Intel Microcommunications Handbook, p2-308
  720.  */
  721. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  722. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  723. if((xread_scc(hp,cmd,R0) & DCD) != 0){
  724. hp->tstate = DEFER;
  725. tdelay(hp,100);
  726. /* defer until DCD transition or timeout */
  727. xwrite_scc(hp,cmd,R15,CTSIE|DCDIE);
  728. restore(i_state);
  729. return;
  730. }
  731. /* p - persist calculation */
  732. if(inportb(hp->cardbase+TMR0) > hp->persist){
  733. inportb(hp->cardbase+TMR0); /* Discard MSB */
  734. hp->tstate = DEFER;
  735. tdelay(hp,hp->slotime);
  736. restore(i_state);
  737. return;
  738. }
  739. inportb(hp->cardbase+TMR0); /* Discard MSB */
  741. rts(hp,ON);   /* Transmitter on */
  742. hp->tstate = ST_TXDELAY;
  743. tdelay(hp,hp->txdelay);
  744. restore(i_state);
  745. return;
  747. case ST_TXDELAY:
  749. /* Get next char to send */
  750. c = *hp->tcp++;
  751. hp->txcnt--;
  752. xwrite_scc(hp,cmd,R0,RES_Tx_CRC);/* reset for next frame */
  754. /* Send abort on underrun */
  755. if(hp->speed){ /* If externally clocked */
  756. xwrite_scc(hp,cmd,R10,CRCPS|NRZI|ABUNDER);
  757. } else {
  758. xwrite_scc(hp,cmd,R10,CRCPS|ABUNDER);
  759. }
  761. xwrite_scc(hp,cmd,R8,c); /* First char out now */
  762. xwrite_scc(hp,cmd,R0,RES_EOM_L);/* Reset end of message latch */
  764. /* select transmit interrupts to enable */
  766. xwrite_scc(hp,cmd,R15,TxUIE); /* allow Underrun int only */
  767. xwrite_scc(hp,cmd,R0,RES_EXT_INT);
  768. /* Tx/Extern ints on */
  769. xwrite_scc(hp,cmd,R1,TxINT_ENAB|EXT_INT_ENAB);
  771. hp->tstate = ACTIVE; /* char going out now */
  772. restore(i_state);
  773. return;
  774. }
  776. /* Receive Mode only
  777.  * This triggers when hunt mode is entered, & since an ABORT
  778.  * automatically enters hunt mode, we use that to clean up
  779.  * any waiting garbage
  780.  */
  781. if((hp->rstate == ACTIVE) && (st & BRK_ABRT)){
  782. (void) xread_scc(hp,cmd,R8);
  783. (void) xread_scc(hp,cmd,R8);
  784. (void) xread_scc(hp,cmd,R8);
  785. hp->rcp = hp->rcvbuf;
  786. hp->rxcnt = 0;       /* rewind on DCD transition */
  787. }
  788. restore(i_state);
  789. }
  791. /* SET Transmit or Receive Mode
  792.  * Set RTS (request-to-send) to modem on Transmit
  793.  */
  794. static void
  795. rts(hp,x)
  796. register struct pichan *hp;
  797. uint16 x;
  798. {
  799. uint16 tc;
  800. long br;
  801. uint16 cmd;
  803. cmd = CTL+hp->base;
  805. /* Reprogram BRG and turn on transmitter to send flags */
  806. if(x == ON){ /* Turn Tx ON and Receive OFF */
  807. /* Exints off first to avoid abort int */
  808. xwrite_scc(hp,cmd,R15,0);
  809. xwrite_scc(hp,cmd,R3,Rx8); /* Rx off */
  810. hp->rstate = IDLE;
  811. if(cmd & 2){ /* if channel a */
  812. /* Set up for TX dma */
  813. xwrite_scc(hp,cmd,R1,WT_FN_RDYFN|EXT_INT_ENAB);
  814. } else {
  815. xwrite_scc(hp,cmd,R1,0); /* No interrupts */
  816. }
  817. if(hp->speed){ /* if internally clocked */
  818. br = hp->speed; /* get desired speed */
  819. tc = (XTAL/br)-2; /* calc 1X BRG divisor */
  820. xwrite_scc(hp,cmd,R12,tc&0xFF);     /* lower byte */
  821. xwrite_scc(hp,cmd,R13,(tc>>8)&0xFF);/* upper byte */
  822. }
  823. xwrite_scc(hp,cmd,R5,TxCRC_ENAB|RTS|TxENAB|Tx8|DTR);
  824. /* Transmitter now on */
  825. } else { /* Tx OFF and Rx ON */
  826. hp->tstate = IDLE;
  827. xwrite_scc(hp,cmd,R5,Tx8|DTR);  /*  TX off */
  829. if(hp->speed){ /* if internally clocked */
  830. /* Reprogram BRG for 32x clock for receive DPLL */
  831. /* BRG off, keep Pclk source */
  832. xwrite_scc(hp,cmd,R14,BRSRC);
  833. br = hp->speed; /* get desired speed */
  834. /* calc 32X BRG divisor */
  835. tc = ((XTAL/32)/br)-2;
  836. xwrite_scc(hp,cmd,R12,tc&0xFF); /* lower byte */
  837. xwrite_scc(hp,cmd,R13,(tc>>8)&0xFF);/* upper byte */
  838. /* SEARCH mode, BRG source */
  839. xwrite_scc(hp,cmd,R14,BRSRC|SEARCH);
  840. /* Enable the BRG */
  841. xwrite_scc(hp,cmd,R14,BRSRC|BRENABL);
  842. }
  843. /* Now, turn on the receiver and hunt for a flag */
  844. xwrite_scc(hp,cmd,R3,RxENABLE|RxCRC_ENAB|Rx8);
  845. hp->rstate = ACTIVE; /* Normal state */
  847. if(cmd & 2){/* if channel a */
  848. setup_rx_dma(hp);
  849. } else {
  850. /* reset error bits */
  851. /* xwrite_scc(hp,cmd,R0,ERR_RES); */
  852. /* reset buffer pointers */
  853. hp->rcp = hp->rcvbuf;
  854. hp->rxcnt = 0;
  855. xwrite_scc(hp,cmd,R1,(INT_ALL_Rx|EXT_INT_ENAB));
  856. }
  857. xwrite_scc(hp,cmd,R15,BRKIE); /* allow ABORT int */
  858. /* Hold tx off long enough for other station to reply */
  859. hp->deftime = msclock() + hp->txdelay + 500;
  860. }
  861. }
  863. void
  864. setup_rx_dma(hp)
  865. register struct pichan *hp;
  866. {
  867. int cmd;
  868. int dmaport;
  869. int i_state;
  871. cmd = hp->base+CTL;
  872. dmaport = DMABASE+2*hp->dmachan;
  874. i_state = dirps();
  875. if(!hp->rcvbuf){
  876. /* No rx buffer available */
  877. restore(i_state);
  878. return;
  879. }
  881. /* Get ready for RX DMA */
  882. xwrite_scc(hp,cmd,R1,WT_FN_RDYFN|WT_RDY_RT|INT_ERR_Rx|EXT_INT_ENAB);
  883. outportb(DMA_MASK, DMA_DISABLE|hp->dmachan); /* Disable DMA chan */
  884. /* Set DMA mode register to single transfers, incrementing address,
  885.  * auto init, writes
  886.  */
  887. outportb(DMA_MODE,DMA_RX_MODE|hp->dmachan);
  889. outportb(Page_regs[hp->dmachan],hp->rcvphys >> 16);/* Store in  64K DMA page */
  890. outportb(DMA_RESETFF,0);  /* reset byte pointer flipflop */
  891. /* Output buffer start (dest) address */
  892. outportb(dmaport,hp->rcvphys);
  893. outportb(dmaport,hp->rcvphys >> 8);
  894. /* output DMA maximum byte count */
  895. dmaport++;
  896. outportb(dmaport,hp->bufsiz - 1);
  897. outportb(dmaport, (hp->bufsiz - 1) >> 8);
  898. /* Unmask channel 1 (start DMA) */
  899. outportb(DMA_MASK, DMA_ENABLE|hp->dmachan); /* Enable DMA chan */
  901. /* If a packet is already coming in, this line is supposed
  902.  * to mess up the crc to avoid receiving a partial packet
  903.  */
  904. xwrite_scc(hp,cmd,R0,RES_Rx_CRC);
  906. /* Enable RX dma */
  907. xwrite_scc(hp,cmd,R1,WT_RDY_ENAB|WT_FN_RDYFN|WT_RDY_RT|INT_ERR_Rx|EXT_INT_ENAB);
  909. restore(i_state);
  910. }
  912. void
  913. setup_tx_dma(hp)
  914. struct pichan *hp;
  915. {
  916. int dmaport;
  917. uint16 length;
  918. int i_state;
  920. length = hp->txcnt - 1;
  921. dmaport = DMABASE + 2*hp->dmachan;
  922. i_state = dirps();
  924. outportb(DMA_MASK, DMA_DISABLE|hp->dmachan); /* Disable DMA chan */
  925. /* Set DMA mode register to single transfers, incrementing address,
  926.  * no auto init, reads
  927.    */
  928. outportb(DMA_MODE,DMA_TX_MODE|hp->dmachan);
  930. outportb(Page_regs[hp->dmachan],hp->sndphys >> 16); /* Store in 64K DMA page */
  931. outportb(DMA_RESETFF,0); /* reset byte pointer flipflop */
  932. outportb(dmaport,hp->sndphys); /* Output buffer start (source) address */
  933. outportb(dmaport,hp->sndphys >> 8);
  934. /* output byte count */
  935. dmaport++;
  936. outportb(dmaport,length);
  937. outportb(dmaport, length >> 8);
  939. restore(i_state);
  940. }
  942. /* Initialize pi controller parameters */
  943. static int
  944. scc_init(hp)
  945. register struct pichan *hp;
  946. {
  947. uint16 tc;
  948. long br;
  949. register uint16 cmd;
  950. int i_state;
  952. /* Initialize 8530 channel for SDLC operation */
  954. cmd = CTL+hp->base;
  955. #ifdef notdef
  956. printf("Pi: Initializing Channel %c - Base = %xn",cmd&2?'A':'B',cmd&~CTL);
  957. #endif
  958. i_state = dirps();
  960. switch(cmd & 2){
  961. case 2:
  962. xwrite_scc(hp,cmd,R9,CHRA); /* Reset channel A */
  963. xwrite_scc(hp,cmd,R2,0xff); /* Initialize interrupt vector */
  964. break;
  965. case 0:
  966. xwrite_scc(hp,cmd,R9,CHRB); /* Reset channel B */
  967. break;
  968. }
  970. /* Deselect all Rx and Tx interrupts */
  971. xwrite_scc(hp,cmd,R1,0);
  973. /* Turn off external interrupts (like CTS/CD) */
  974. xwrite_scc(hp,cmd,R15,0);
  976. /* X1 clock, SDLC mode */
  977. xwrite_scc(hp,cmd,R4,SDLC|X1CLK);
  979. /* Now some misc Tx/Rx parameters */
  980. /* CRC PRESET 1, NRZI Mode */
  981. if(hp->speed){
  982. xwrite_scc(hp,cmd,R10,CRCPS|NRZI);
  983. /* Tx Clk from BRG. Rcv Clk from DPLL, TRxC pin outputs DPLL */
  984. xwrite_scc(hp,cmd,R11,TCBR|RCDPLL|TRxCDP|TRxCOI);
  985. } else {
  986. xwrite_scc(hp,cmd,R10,CRCPS);
  987. /* Tx Clk from Trxcl. Rcv Clk from Rtxcl, TRxC pin is input */
  988. xwrite_scc(hp,cmd,R11,TCTRxCP);
  989. }
  991. /* Null out SDLC start address */
  992. xwrite_scc(hp,cmd,R6,0);
  994. /* SDLC flag */
  995. xwrite_scc(hp,cmd,R7,FLAG);
  997. /* Set up the Transmitter but don't enable it
  998.  *  DTR, 8 bit TX chars only - TX NOT ENABLED
  999.  */
  1000. xwrite_scc(hp,cmd,R5,Tx8|DTR);
  1002. /* Receiver - intial setup only - more later */
  1003. xwrite_scc(hp,cmd,R3,Rx8);         /* 8 bits/char */
  1005. /* Setting up BRG now - turn it off first */
  1006. xwrite_scc(hp,cmd,R14,BRSRC);      /* BRG off, but keep Pclk source */
  1008. /* set the 32x time constant for the BRG in Receive mode */
  1010. if(hp->speed){
  1011. br = hp->speed;  /* get desired speed */
  1012. tc = ((XTAL/32)/br)-2; /* calc 32X BRG divisor */
  1013. } else {
  1014. tc = 14;
  1015. }
  1017. xwrite_scc(hp,cmd,R12,tc&0xFF);      /* lower byte */
  1018. xwrite_scc(hp,cmd,R13,(tc>>8)&0xFF); /* upper byte */
  1020. /* Following subroutine sets up and ENABLES the receiver */
  1021. rts(hp,OFF);    /* TX OFF and RX ON */
  1023. if(hp->speed){
  1024. /* DPLL frm BRG, BRG src PCLK */
  1025. xwrite_scc(hp,cmd,R14,BRSRC|SSBR);
  1026. } else {
  1027. /* DPLL frm rtxc,BRG src PCLK */
  1028. xwrite_scc(hp,cmd,R14,BRSRC|SSRTxC);
  1029. }
  1030. xwrite_scc(hp,cmd,R14,BRSRC|SEARCH); /* SEARCH mode, keep BRG source */
  1031. xwrite_scc(hp,cmd,R14,BRSRC|BRENABL);/* Enable the BRG */
  1033. if(!(cmd & 2)) /* if channel b */
  1034. xwrite_scc(hp,cmd,R1,(INT_ALL_Rx|EXT_INT_ENAB));
  1036. xwrite_scc(hp,cmd,R15,BRKIE);     /* ABORT int */
  1038. /* Now, turn on the receiver and hunt for a flag */
  1039. xwrite_scc(hp,cmd,R3,RxENABLE|RxCRC_ENAB|Rx8);
  1041. restore(i_state);
  1042. return 0;
  1043. }
  1046. /* Attach a PI interface to the system
  1047.  * argv[0]: hardware type, must be "pi"
  1048.  * argv[1]: I/O address, e.g., "0x300"
  1049.  * argv[2]: vector, e.g., "2"
  1050.  * argv[3]: dma channel (1..3)
  1051.  * argv[4]: mode, must be:
  1052.  *     "ax25" (AX.25 UI frame format)
  1053.  * argv[5]: interface label, e.g., "pi0"
  1054.  * argv[6]: receiver packet buffer size in bytes
  1055.  * argv[7]: maximum transmission unit, bytes
  1056.  * argv[8]: channel A interface speed, e.g, "1200", 0 = ext. clock
  1057.  * argv[9]: channel B interface speed
  1058.  * argv[10]: First IP address, optional (defaults to Ip_addr);
  1059.  * argv[11]: Second IP address, optional (defaults to Ip_addr);
  1060.  */
  1061. int
  1062. pi_attach(argc,argv)
  1063. int argc;
  1064. char *argv[];
  1065. {
  1066. register struct iface *if_pca,*if_pcb;
  1067. struct pichan *hp;
  1068. int dev;
  1069. int n;
  1070. char *cp;
  1072. if(acc_delay == 0){ /* Only do this once */
  1073. /* Adapt recovery time delay to processor speed */
  1074. set_acc_delay();
  1075. }
  1076. /* Quick check to make sure args are good and mycall is set */
  1077. if(setencap(NULL,argv[4]) == -1){
  1078. printf("PI: Mode %s unknown for interface %sn",
  1079. argv[4],argv[5]);
  1080. return -1;
  1081. }
  1082. if(if_lookup(argv[5]) != NULL){
  1083. printf("PI: Interface %s already existsn",argv[5]);
  1084. return -1;
  1085. }
  1086. if(Mycall[0] == ''){
  1087. printf("PI: Set mycall firstn");
  1088. return -1;
  1089. }
  1090. /* Note: each card must have a unique address, IRQ and DMA */
  1092. if(pinbr >= PIMAX){
  1093. printf("PI: Maximum of %d PI cards supportedn",PIMAX);
  1094. return -1;
  1095. }
  1096. dev = pinbr++;
  1098. /* Initialize hardware-level control structure */
  1099. Pi[dev].addr = htoi(argv[1]);
  1100. Pi[dev].vec = atoi(argv[2]);
  1101. if(strchr(argv[2],'c') != NULL)
  1102. Pi[dev].chain = 1;
  1103. else
  1104. Pi[dev].chain = 0;
  1106. /* Set up counter chip */
  1107. /* 500 uS square wave */
  1108. outportb(Pi[dev].addr+TMRCMD, SC0|LSB_MSB|MODE3);
  1109. for(n=0; n<5;n++) /* satisfy access time restriction */
  1110. ;
  1111. outportb(Pi[dev].addr+TMR0, 922 & 0xFF); 
  1112. for(n=0; n<5;n++) /* satisfy access time restriction */
  1113. ;
  1114. outportb(Pi[dev].addr+TMR0, 922 >> 8);
  1115. for(n=0; n<5;n++) /* satisfy access time restriction */
  1116. ;
  1118. /* Save original interrupt vector */
  1119. Pi[dev].oldvec = getirq(Pi[dev].vec);
  1121. /* Set new interrupt vector */
  1122. if(setirq(Pi[dev].vec,pihandle[dev]) == -1){
  1123. printf("PI: IRQ %u out of rangen",Pi[dev].vec);
  1124. pinbr--;
  1125. return -1;
  1126. }
  1128. if((atoi(argv[3]) < 1) || (atoi(argv[3]) > 3)){
  1129. printf("PI: DMA %d out of rangen",atoi(argv[3]));
  1130. pinbr--;
  1131. return -1;
  1132. }
  1134. /* set params in pichan table for CHANNEL B */
  1135. hp = &Pichan[2*dev+1]; /* pi1 is offset 1 */
  1136. hp->dmachan = 0; /* Channel B does not have dma */
  1137. hp->cardbase = Pi[dev].addr;
  1138. hp->stata = Pi[dev].addr + CHANA + CTL; /* permanent status */
  1139. hp->statb = Pi[dev].addr + CHANB + CTL; /* addrs for CHANA/B*/
  1140. hp->speed = (uint16)atoi(argv[9]);
  1141. hp->base = Pi[dev].addr + CHANB;
  1142. hp->bufsiz = atoi(argv[6]);
  1143. hp->tstate = IDLE;
  1144. /* default channel access Params */
  1145. hp->txdelay = 30; /* 300 Ms */
  1146. hp->persist = 128; /* 50% persistence */
  1147. hp->slotime = 30; /* 300 Ms */
  1148. hp->squeldelay = 3; /* 30 Ms */
  1150. xwrite_scc(hp,CTL+hp->stata,R9,FHWRES);  /* Hardware reset */
  1151. /* one time only */
  1152. /* Disable interrupts with Master interrupt ctrl reg */
  1153. xwrite_scc(hp,CTL+hp->stata,R9,0);
  1155. scc_init(hp);
  1157. /* Pre-allocate a receive DMA buffer */
  1158. hp->rcvbuf = dma_malloc(&hp->rcvphys,hp->bufsiz);
  1159. if(hp->rcvbuf == NULL){
  1160. /* No memory, abort receiver */
  1161. printf("PI: No memory available for receive buffern");
  1162. /* Restore original interrupt vector */
  1163. setirq(Pi[dev].vec,Pi[dev].oldvec);
  1164. pinbr--;
  1165. return -1;
  1166. }
  1167. /* Pre-allocate a transmit DMA buffer */
  1168. hp->sndbuf = dma_malloc(&hp->sndphys,hp->bufsiz);
  1169. if(hp->sndbuf == NULL){
  1170. /* No memory, abort */
  1171. printf("PI: No memory available for transmit buffern");
  1172. /* Restore original interrupt vector */
  1173. setirq(Pi[dev].vec,Pi[dev].oldvec);
  1174. pinbr--;
  1175. free(hp->rcvbuf);
  1176. return -1;
  1177. }
  1178. hp->sndq = NULL;
  1180. /* set params in pichan table for CHANNEL A */
  1181. hp = &Pichan[2*dev]; /* pi0a is offset 0 */
  1182. hp->dmachan = (unsigned char)atoi(argv[3]);
  1183. /* Verify dma channel */
  1184. if(hp->dmachan >= 8){
  1185. printf("PI: DMA channel %d out of rangen",hp->dmachan);
  1186. free(hp->rcvbuf);
  1187. free(hp->sndbuf);
  1188. /* Restore original interrupt vector */
  1189. setirq(Pi[dev].vec,Pi[dev].oldvec);
  1190. pinbr--;
  1191. return -1;
  1192. }
  1193. hp->cardbase = Pi[dev].addr;
  1194. hp->speed = (uint16)atoi(argv[8]);
  1195. hp->base = Pi[dev].addr + CHANA;
  1196. hp->bufsiz = atoi(argv[6]);
  1197. hp->tstate = IDLE;
  1198. /* default channel access Params */
  1199. hp->txdelay = 15; /* 15 mS */
  1200. hp->persist = 128; /* 50% persistence */
  1201. hp->slotime = 15; /* 15 mS */
  1202. hp->squeldelay = 1; /* 1 mS */
  1204. /* Pre-allocate a receive buffer */
  1205. hp->rcvbuf = dma_malloc(&hp->rcvphys,hp->bufsiz);
  1206. if(hp->rcvbuf == NULL){
  1207. /* No memory, abort receiver */
  1208. printf("PI: No memory available for receive buffersn");
  1209. /* Restore original interrupt vector */
  1210. setirq(Pi[dev].vec,Pi[dev].oldvec);
  1211. pinbr--;
  1212. return -1;
  1213. }
  1214. hp->sndq = NULL;
  1216. /* Get a buffer for tx which does not cross a dma boundary */
  1217. hp->sndbuf = dma_malloc(&hp->sndphys,hp->bufsiz);
  1218. if(hp->sndbuf == NULL){
  1219. printf("PI: No memory available for transmit buffer");
  1220. /* Restore original interrupt vector */
  1221. setirq(Pi[dev].vec,Pi[dev].oldvec);
  1222. pinbr--;
  1223. free(hp->rcvbuf);
  1224. return -1;
  1225. }
  1226. /* Create interface structures and fill in details */
  1227. if_pca = (struct iface *)callocw(1,sizeof(struct iface));
  1228. if_pcb = (struct iface *)callocw(1,sizeof(struct iface));
  1230. if_pca->addr = if_pcb->addr = Ip_addr;
  1231. if(argc > 10)
  1232. if_pca->addr = resolve(argv[10]);
  1233. if(argc > 11)
  1234. if_pcb->addr = resolve(argv[11]);
  1236. if(if_pca->addr == 0 || if_pcb->addr == 0)
  1237. printf("PI: No IP address!n");
  1239. /* Append "a" to interface associated with A channel */
  1240. if_pca->name = malloc((unsigned)strlen(argv[5])+2);
  1241. strcpy(if_pca->name,argv[5]);
  1242. strcat(if_pca->name,"a");
  1243. /* Append "b" to interface associated with B channel */
  1244. if_pcb->name = malloc((unsigned)strlen(argv[5])+2);
  1245. strcpy(if_pcb->name,argv[5]);
  1246. strcat(if_pcb->name,"b");
  1248. if_pcb->mtu = if_pca->mtu = atoi(argv[7]);
  1249. if_pcb->ioctl = if_pca->ioctl = pi_ctl;
  1250. if_pca->dev = 2*dev; /* pi0a */
  1251. if_pcb->dev = 2*dev + 1; /* pi0b */
  1252. if_pcb->stop = if_pca->stop = pi_stop;
  1253. if_pcb->raw = if_pca->raw = pi_raw;
  1255. /* Must succeed, was checked at top */
  1256. setencap(if_pca,argv[4]);
  1257. setencap(if_pcb,argv[4]);
  1259. if(if_pcb->hwaddr == NULL)
  1260. if_pcb->hwaddr = mallocw(AXALEN);
  1261. memcpy(if_pcb->hwaddr,Mycall,AXALEN);
  1262. if(if_pca->hwaddr == NULL)
  1263. if_pca->hwaddr = mallocw(AXALEN);
  1264. memcpy(if_pca->hwaddr,Mycall,AXALEN);
  1266.         Pichan[2*dev].iface = if_pca;
  1267.         Pichan[2*dev+1].iface = if_pcb;
  1269. /* Link em in to the interface chain */
  1270. if_pca->next = if_pcb;
  1271. if_pcb->next = Ifaces;
  1272. Ifaces = if_pca;
  1274. scc_init(hp);
  1275. /* master interrupt enable */
  1276. xwrite_scc(hp,CTL+hp->base,R9,MIE|NV);
  1278. /* Enable interrupt */
  1279. maskon(Pi[dev].vec);
  1281. cp = if_name(if_pca," tx");
  1282. if_pca->txproc = newproc(cp,512,if_tx,0,if_pca,NULL,0);
  1283. free(cp);
  1284. cp = if_name(if_pcb," tx");
  1285. if_pcb->txproc = newproc(cp,512,if_tx,0,if_pcb,NULL,0);
  1286. free(cp);
  1287. return 0;
  1288. }
  1290. /* Shut down interface */
  1291. int
  1292. pi_stop(iface)
  1293. struct iface *iface;
  1294. {
  1295. uint16 dev;
  1296. struct pichan *hp;
  1298. dev = iface->dev;
  1299. if(dev & 1) /* Because there are 2 devices per card */
  1300. return 0;
  1301. dev >>= 1; /* Convert back into pi number */
  1302. hp = &Pichan[2*dev]; /* pi0a is offset 0 */
  1304. outportb(DMA_MASK, DMA_DISABLE|hp->dmachan); /* Disable DMA channel */
  1306. /* Turn off interrupts */
  1307. maskoff(Pi[dev].vec);
  1309. /* Restore original interrupt vector */
  1310. setirq(Pi[dev].vec,Pi[dev].oldvec);
  1312. /* Force hardware reset */
  1313. xwrite_scc(&Pichan[2*dev],CTL+Pi[dev].addr + CHANA,R9,FHWRES);
  1315. return 0;
  1316. }
  1318. /* Send raw packet on pi card */
  1319. int
  1320. pi_raw(
  1321. struct iface *iface,
  1322. struct mbuf **bpp
  1323. ){
  1324. char kickflag;
  1325. struct pichan *hp;
  1326. int i_state;
  1328. dump(iface,IF_TRACE_OUT,*bpp);
  1329. iface->rawsndcnt++;
  1330. iface->lastsent = secclock();
  1332. hp = &Pichan[iface->dev];
  1333. kickflag = (hp->sndq == NULL) & (hp->sndbuf == NULL);
  1334. enqueue(&hp->sndq,bpp);
  1335. hp->enqueued++;
  1336. if(kickflag){
  1337. /* simulate interrupt to xmit */
  1338. switch(hp->base & 2){
  1339. case 2:
  1340. a_txint(hp); /* process interrupt */
  1341. break;
  1342. case 0:
  1343. i_state = dirps();
  1344. if(hp->tstate == IDLE)
  1345. b_txint(hp);
  1346. restore(i_state);
  1347. break;
  1348. }
  1349. }
  1350. return 0;
  1351. }
  1353. /* display PI Channel stats */
  1354. int
  1355. dopistat()
  1356. {
  1357. struct pichan *hp;
  1358. int i;
  1360. printf("PI Board Statistics:nn");
  1361. printf("Base Addr  Rxints  Txints  Exints  TxFrms  RxFrms  Crcerr  RxOvrs  TxUndr n");
  1362. printf("---------  ------  ------  ------  ------  ------  ------  ------  ------ n");
  1363. for(i=0; i<pinbr*2; i++){
  1364. hp = &Pichan[i];
  1366. printf("0x%03x    % 8lu% 8lu% 8lu% 8u% 8u% 8u% 8u% 8unRcv State=%s ",
  1367.  hp->base, hp->rxints, hp->txints, hp->exints, hp->enqueued,
  1368.  hp->rxframes, hp->crcerr, hp->rovers, hp->tunders,
  1369.  hp->rstate==0 ?
  1370.   "IDLE" : hp->rstate==1 ?
  1371.    "ACTIVE" : hp->rstate==2 ?
  1372.     "RXERROR" : hp->rstate==3 ?
  1373.      "RXABORT":"TOOBIG"
  1374. );
  1376. printf("Tstate = %sn",
  1377.  hp->tstate == 0 ?
  1378.   "IDLE" : hp->tstate == 1 ?
  1379.    "ACTIVE" : hp->tstate == 2 ?
  1380.     "UNDERRUN" : hp->tstate == 3 ?
  1381.      "FLAGOUT" : hp->tstate == 4 ?
  1382.       "DEFER" : hp->tstate == 5 ?
  1383.        "TXDELAY" : "CRCOUT"
  1384. );
  1385. }
  1386. return 0;
  1387. }
  1389. /* Subroutine to set kiss params in channel tables */
  1390. int32
  1391. pi_ctl(iface,cmd,set,val)
  1392. struct iface *iface;
  1393. int cmd;
  1394. int set;
  1395. int32 val;
  1396. {
  1397. struct pichan *hp;
  1398. int32 t,ca;
  1400. hp = &Pichan[iface->dev]; /* point to channel table */
  1401. switch(cmd){
  1402. case PARAM_TXDELAY:
  1403. if(set)
  1404. hp->txdelay = val;
  1405. return hp->txdelay;
  1406. case PARAM_PERSIST:
  1407. if(set)
  1408. hp->persist = val;
  1409. return hp->persist;
  1410. case PARAM_SLOTTIME:
  1411. if(set)
  1412. hp->slotime = val;
  1413. return hp->slotime;
  1414. case PARAM_TXTAIL:
  1415. if(set)
  1416. hp->squeldelay = val;
  1417. return hp->squeldelay;
  1418. case PARAM_MUTE:
  1419. if(set){
  1420. if(val == -1){
  1421. /* Special case for duration of a CTS */
  1422. val = hp->txdelay + 500;
  1423. }
  1424. hp->deftime = msclock() + val;
  1425. }
  1426. t = msclock();
  1427. ca = hp->deftime - t;
  1428. if(ca < 0){
  1429. hp->deftime = t;
  1430. ca = 0;
  1431. }
  1432. return ca;
  1433. }
  1434. return -1;
  1435. }