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

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

TCP/IP协议栈

开发平台：

Visual C++

drsi.c：源码内容
  1. /*
  2.  * Version with Stopwatches
  3.  *
  4.  * 0 - Not used
  5.  * 1 - rx_fsm run time
  6.  * 2 - drtx_active run time (per character tx time)
  7.  * 
  8.  * Interface driver for the DRSI board for KA9Q's TCP/IP on an IBM-PC ONLY!
  9.  *
  10.  * Derived from a driver written by Art Goldman, WA3CVG
  11.  * (c) Copyright 1987 All Rights Reserved
  12.  * Permission for non-commercial use is hereby granted provided this notice
  13.  * is retained.  For info call: (301) 997-3838.
  14.  *
  15.  * Heavily re-written from the original,  a driver for the EAGLE board into
  16.  * a driver for the DRSI PC* Packet adpator. Copyright as original, all
  17.  * amendments likewise providing credit given and notice retained.
  18.  * Stu Phillips - N6TTO, W6/G8HQA (yes Virginia,  really !).
  19.  * For info call: (408) 285-4142
  20.  *
  21.  * This driver supports 1 (one) DRSI board.
  22.  * 
  23.  * Reformatted and added ANSI-style declarations, integrated into NOS
  24.  * by KA9Q, 10/14/89
  25.  *
  26.  * Latest set of defect fixes added 1/2/90 by N6TTO
  27.  * 1. Made P-PERSIST work properly
  28.  * 2. Fixed UNDERRUN bug when in DEFER state
  29.  * 3. Tx now defers correctly when DCD is high (!)
  30.  *
  31.  * Changed 3/4/90 by N6TTO
  32.  * Changed method of enabling the IRQ to the 8259 to call maskon()
  33.  * instead of clrbit(); change made to allow interrupts > 8 to work
  34.  * on an AT.
  35.  *
  36.  * Changed 11/14/90 by N6TTO
  37.  * Fixed incompatiblity between current NOS memory allocation scheme
  38.  * and changes made to speed up drsi transmit state machine.
  39.  *
  40.  */
  42. #include <stdio.h>
  43. #include <dos.h>
  44. #include <time.h>
  45. #include "global.h"
  46. #include "mbuf.h"
  47. #include "iface.h"
  48. #include "pktdrvr.h"
  49. #include "netuser.h"
  50. #include "drsi.h"
  51. #include "ax25.h"
  52. #include "trace.h"
  53. #include "nospc.h"
  54. #include "z8530.h"
  55. #include "devparam.h"
  57. static int32 dr_ctl(struct iface *iface,int cmd,int set,int32 val);
  58. static int dr_raw(struct iface *iface,struct mbuf **bpp);
  59. static int dr_stop(struct iface *iface);
  60. static void dr_wake(struct drchan *hp,int rx_or_tx,
  61. void (*routine)(struct drchan *),int ticks);
  62. static int drchanparam(struct drchan *hp);
  63. static void drexint(struct drchan *hp);
  64. static void drinitctc(unsigned port);
  65. static void drrx_active(struct drchan *hp);
  66. static void drrx_enable(struct drchan *hp);
  67. static void drtx_active(struct drchan *hp);
  68. static void drtx_defer(struct drchan *hp);
  69. static void drtx_downtx(struct drchan *hp);
  70. static void drtx_flagout(struct drchan *hp);
  71. static void drtx_idle(struct drchan *hp);
  72. static void drtx_rrts(struct drchan *hp);
  73. static void drtx_tfirst(struct drchan *hp);
  74. static char read_ctc(unsigned port,unsigned reg);
  75. static void rx_fsm(struct drchan *hp);
  76. static void tx_fsm(struct drchan *hp);
  77. static void write_ctc(uint16 port,uint8 reg,uint8 val);
  79. struct DRTAB Drsi[DRMAX]; /* Device table - one entry per card */
  80. INTERRUPT (*Drhandle[])(void) = { dr0vec };  /* handler interrupt vector table */
  81. struct drchan Drchan[2*DRMAX];  /* channel table - 2 entries per card */
  82. uint16 Drnbr;
  84. /* Set specified routine to be 'woken' up after specified number
  85.  * of ticks (allows CPU to be freed up and reminders posted);
  86.  */
  87. static void
  88. dr_wake(hp, rx_or_tx, routine, ticks)
  89. struct drchan *hp;
  90. int rx_or_tx;
  91. void (*routine)(struct drchan *);
  92. int ticks;
  93. {
  94. hp->w[rx_or_tx].wcall = routine;
  95. hp->w[rx_or_tx].wakecnt = ticks;
  96. }
  98. /* Master interrupt handler.  One interrupt at a time is handled.
  99.  * here. Service routines are called from here.
  100.  */
  101. INTERRUPT (far *(drint)(dev))()
  102. int dev;
  103. {
  104. register char st;
  105. register uint16 pcbase, i;
  106. struct drchan *hpa,*hpb;
  107. struct DRTAB *dp;
  109. dp = &Drsi[dev];
  110. dp->ints++;
  111. pcbase = dp->addr;
  112. hpa = &Drchan[2 * dev];
  113. hpb = &Drchan[(2 * dev)+1];
  115. yuk:
  116. /* Check CTC for timer interrupt */
  117. st = read_ctc(pcbase, Z8536_CSR3);
  118. if(st & Z_IP){
  119. /* Reset interrupt pending */
  120. write_ctc(pcbase, Z8536_CSR3, Z_CIP|Z_GCB);
  121. for(i=0;i<=1;i++){
  122. if(hpa->w[i].wakecnt){
  123. if(--hpa->w[i].wakecnt == 0){
  124. (hpa->w[i].wcall)(hpa);
  125. }
  126. }
  127. if(hpb->w[i].wakecnt){
  128. if(--hpb->w[i].wakecnt == 0){
  129. (hpb->w[i].wcall)(hpb);
  130. }
  131. }
  132. }
  133. }
  134. /* Check the SIO for interrupts */
  136. /* Read interrupt status register from channel A */
  137. while((st = read_scc(pcbase+CHANA+CTL,R3)) != 0){
  138. /* Use IFs to process ALL interrupts pending
  139.  * because we need to check all interrupt conditions
  140.  */
  141. if(st & CHARxIP){
  142. /* Channel A Rcv Interrupt Pending */
  143. rx_fsm(hpa);
  144. }
  145. if(st & CHBRxIP){
  146. /* Channel B Rcv Interrupt Pending */
  147. rx_fsm(hpb);
  148. }
  149. if(st & CHATxIP){
  150. /* Channel A Transmit Int Pending */
  151. tx_fsm(hpa);
  152. }
  153. if(st & CHBTxIP){
  154. /* Channel B Transmit Int Pending */
  155. tx_fsm(hpb);
  156. }
  157. if(st & CHAEXT){
  158. /* Channel A External Status Int */
  159. drexint(hpa);
  160. }
  161. if(st & CHBEXT){
  162. /* Channel B External Status Int */
  163. drexint(hpb);
  164. }
  165. /* Reset highest interrupt under service */
  166. write_scc(hpa->base+CTL,R0,RES_H_IUS);
  168. } /* End of while loop on int processing */
  169. if(read_ctc(pcbase, Z8536_CSR3) & Z_IP)
  170. goto yuk;
  171. return dp->chain ? dp->oldvec : NULL;
  172. }
  175. /* DRSI SIO External/Status interrupts
  176.  * This can be caused by a receiver abort, or a Tx UNDERRUN/EOM.
  177.  * Receiver automatically goes to Hunt on an abort.
  178.  *
  179.  * If the Tx Underrun interrupt hits, change state and
  180.  * issue a reset command for it, and return.
  181.  */
  182. static void
  183. drexint(hp)
  184. register struct drchan *hp;
  185. {
  186. register int base = hp->base;
  187. char st;
  188. int i_state;
  190. i_state = dirps();
  191. hp->exints++;
  193. st = read_scc(base+CTL,R0);     /* Fetch status */
  195. /* Check for Tx UNDERRUN/EOM - only in Transmit Mode */
  196.         /* Note that the TxEOM bit remains set once we go    */
  197. /* back to receive.  The following qualifications    */
  198. /* are necessary to prevent an aborted frame causing */
  199. /* a queued transmit frame to be tossed when in      */
  200. /* DEFER state on transmit.      */
  201. if((hp->tstate != DEFER) && (hp->rstate==0) && (st & TxEOM)){
  202. if(hp->tstate != UNDERRUN){
  203. /* This is an unexpected underrun.  Discard the current
  204.  * frame (there's no way to rewind),  kill the transmitter
  205.  * and return to receive with a wakeup posted to get the
  206.  * next (if any) frame.  Any recovery will have to be done
  207.  * by higher level protocols (yuk).
  208.  */
  209. write_scc(base, R5, Tx8|DTR); /* Tx off now */
  210. write_scc(base, R1, 0); /* Prevent ext.status int */
  211. write_scc(base, R0, RES_Tx_P);  /* Reset Tx int pending */
  212. write_scc(base, R0, ERR_RES);
  213. write_scc(base, R0, RES_EOM_L); /* Reset underrun latch */
  214. free_p(&hp->sndbuf);
  215. hp->tstate = IDLE;
  216. hp->tx_state = drtx_idle;
  217. dr_wake(hp, TX, tx_fsm, hp->slotime);
  218. hp->rstate = ENABLE;
  219. hp->rx_state = drrx_enable;
  220. drrx_enable(hp);
  221. }
  222. }
  223. /* Receive Mode only
  224.  * This triggers when hunt mode is entered, & since an ABORT
  225.  * automatically enters hunt mode, we use that to clean up
  226.  * any waiting garbage
  227.  */
  228. if((hp->rstate != IDLE) && (st & BRK_ABRT)){
  229. if(hp->rcvbuf != NULL){
  230. hp->rcp = hp->rcvbuf->data;
  231. hp->rcvbuf->cnt = 0;
  232. }
  233. while(read_scc(base,R0) & Rx_CH_AV)
  234. (void) inportb(base+DATA);
  235. hp->aborts++;
  236. hp->rstate = ACTIVE;
  237. write_scc(base, R0, ERR_RES);
  238. }
  239. /* reset external status latch */
  240. write_scc(base,R0,RES_EXT_INT);
  241. restore(i_state);
  242. }
  244. /* Receive Finite State Machine - dispatcher */
  245. static void
  246. rx_fsm(hp)
  247. struct drchan *hp;
  248. {
  249. int i_state;
  251. i_state = dirps();
  252. hp->rxints++;
  253. (*hp->rx_state)(hp);
  254. restore(i_state);
  255. }
  257. /* drrx_enable
  258.  * Receive ENABLE state processor
  259.  */
  260. static void
  261. drrx_enable(hp)
  262. struct drchan *hp;
  263. {
  264. register uint16 base = hp->base;
  266. write_scc(base, R1, INT_ALL_Rx|EXT_INT_ENAB);
  267. write_scc(base, R15, BRKIE); /* Allow ABORT Int */
  268. write_scc(base, R14, BRSRC|BRENABL|SEARCH);
  269. /* Turn on rx and enter hunt mode */
  270. write_scc(base, R3, ENT_HM|RxENABLE|RxCRC_ENAB|Rx8);
  272. if(hp->rcvbuf != NULL){
  273. hp->rcvbuf->cnt = 0;
  274. hp->rcp = hp->rcvbuf->data;
  275. }
  276. hp->rstate = ACTIVE;
  277. hp->rx_state = drrx_active;
  278. }
  280. /* drrx_active
  281.  * Receive ACTIVE state processor
  282.  */
  283. static void
  284. drrx_active(hp)
  285. struct drchan *hp;
  286. {
  287. register uint16 base = hp->base;
  288. unsigned char rse,st;
  289. struct mbuf *bp;
  291. /* Allocate a receive buffer if not already present */
  292. if(hp->rcvbuf == NULL){
  293. bp = hp->rcvbuf = alloc_mbuf(hp->bufsiz);
  294. if(bp == NULL){
  295. /* No buffer - abort the receiver */
  296. write_scc(base, R3, ENT_HM|RxENABLE|RxCRC_ENAB|Rx8);
  297. /* Clear character from rx buffer in SIO */
  298. (void) inportb(base+DATA);
  299. return;
  300. }
  301. hp->rcvbuf->cnt = 0; 
  302. hp->rcp = hp->rcvbuf->data;
  303. }
  305. st = read_scc(base, R0); /* get interrupt status from R0 */
  306. rse = read_scc(base,R1); /* get special status from R1 */
  308. if(st & Rx_CH_AV){
  309. /* there is a char to be stored
  310.  * read special condition bits before reading the data char
  311.  * (already read above)
  312.  */
  313. if(rse & Rx_OVR){
  314. /* Rx overrun - toss buffer */
  315. hp->rcp = hp->rcvbuf->data; /* reset buffer pointers */
  316. hp->rcvbuf->cnt = 0;
  317. hp->rstate = RXERROR; /* set error flag */
  318. hp->rovers++; /* count overruns */
  319. } else if(hp->rcvbuf->cnt >= hp->bufsiz){
  320. /* Too large -- toss buffer */
  321. hp->toobig++;
  322. hp->rcp = hp->rcvbuf->data; /* reset buffer pointers */
  323. hp->rcvbuf->cnt = 0;
  324. hp->rstate = TOOBIG; /* when set, chars are not stored */
  325. }
  326. /* ok, we can store the received character now */
  327. if((hp->rstate == ACTIVE) && ((st & BRK_ABRT) == 0)){
  328. *hp->rcp++ = inportb(base+DATA); /* char to rcv buff */
  329. hp->rcvbuf->cnt++;  /* bump count */
  330. } else {
  331. /* got to empty FIFO */
  332. (void) inportb(base+DATA);
  333. hp->rcp = hp->rcvbuf->data; /* reset buffer pointers */
  334. hp->rcvbuf->cnt = 0;
  335. hp->rstate = RXABORT;
  336. write_scc(base,R0,ERR_RES); /* reset err latch */
  337. }
  338. }
  339. /* The End of Frame bit is ALWAYS associated with a character,
  340.  * usually, it is the last CRC char.  Only when EOF is true can
  341.  * we look at the CRC byte to see if we have a valid frame
  342.  */
  343. if(rse & END_FR){
  344. hp->rxframes++;
  345. /* END OF FRAME -- Make sure Rx was active */
  346. if(hp->rcvbuf->cnt > 0){ /* any data to store */
  347. /* looks like a frame was received
  348.  * now is the only time we can check for CRC error
  349.  */
  350. if((rse & CRC_ERR) || (hp->rstate > ACTIVE) ||
  351.  (hp->rcvbuf->cnt < 10) || (st & BRK_ABRT)){
  352. /* error occurred; toss frame */
  353. if(rse & CRC_ERR)
  354. hp->crcerr++; /* count CRC errs */
  355. hp->rcp = hp->rcvbuf->data;
  356. hp->rcvbuf->cnt = 0;
  357. hp->rstate = ACTIVE;   /* Clear error state */
  358. } else {
  359. /* Here we have a valid frame */
  360. hp->rcvbuf->cnt -= 2;    /* chuck FCS bytes */
  361.     /* queue it in */
  362. net_route(hp->iface,&hp->rcvbuf);
  363. hp->enqueued++;
  364. /* packet queued - reset buffer pointer */
  365. hp->rcvbuf = NULL;
  366. } /* end good frame queued */
  367. }  /* end check for active receive upon EOF */
  368. }
  369. }
  371. /*
  372.  * TX finite state machine - dispatcher
  373.  */
  374. static void
  375. tx_fsm(hp)
  376. struct drchan *hp;
  377. {
  378. int i_state;
  380. i_state = dirps();
  381. if(hp->tstate != DEFER && hp->tstate)
  382. hp->txints++;
  383. (*hp->tx_state)(hp);
  384. restore(i_state);
  385. }
  387. /* drtx_idle
  388.  * Transmit IDLE transmit state processor
  389.  */
  390. static void
  391. drtx_idle(hp)
  392. struct drchan *hp;
  393. {
  394. register uint16 base;
  396. /* Tx idle - is there a frame to transmit ? */
  397. if((hp->sndbuf = dequeue(&hp->sndq)) == NULL){
  398. /* Nothing to send - return to receive mode
  399.  * Turn Tx off - any trailing flag should have been sent
  400.  * by now
  401.  */
  402. #ifdef DRSIDEBUG
  403. printf("Nothing to TXn");
  404. #endif
  405. base = hp->base;
  406. write_scc(base, R5, Tx8|DTR);   /* Tx off now */
  407. write_scc(base, R0, ERR_RES); /* Reset error bits */
  409. /* Delay for squelch tail before enabling receiver */
  410. hp->rstate = ENABLE;
  411. hp->rx_state = drrx_enable;
  412. dr_wake(hp, RX, rx_fsm, hp->squeldelay);
  413. } else {
  414. /* Frame to transmit */
  415. hp->tstate = DEFER;
  416. hp->tx_state = drtx_defer;
  417. drtx_defer(hp);
  418. }
  419. }
  421. /* drtx_defer
  422.  * Transmit DEFER state processor
  423.  */
  424. static void
  425. drtx_defer(hp)
  426. struct drchan *hp;
  427. {
  428. register uint16 base = hp->base;
  430. /* We may have defered a previous tx attempt - in any event...
  431.  * Check DCD in case someone is already transmitting
  432.  * then check to see if we should defer due to P-PERSIST.
  433.  */
  435. #ifdef DRSIDEBUG
  436. printf("drtx_defer - checking for DCDn");
  437. #endif
  438. if((read_scc(base+CTL, R0) & DCD) > 0){
  439. /* Carrier detected - defer */
  440. hp->txdefers++;
  441. dr_wake(hp, TX, tx_fsm, 10); /* Defer for 100 mS */
  442. #ifdef DRSIDEBUG
  443. printf("drtx_defer - TX deferredn");
  444. #endif
  445. return;
  446. }
  448. #ifdef DRSIDEBUG
  449. printf("drtx_defer - checking for P-PERSIST backoffn");
  450. #endif
  451. /* P-PERSIST is checked against channel 3 of the 8536 which is
  452.  * the free running counter for the 10 mS tick; The counter
  453.  * goes through 0x6000 ticks per 10 mS or one tick every
  454.  * 407 nS - this is pretty random compared to the DOS time of
  455.  * day clock (0x40:0x6C) used by the other (EAGLE) drivers.
  456.  */
  457.         if (hp->persist <= read_ctc(base,Z8536_CC3LSB)) {
  458. #ifdef DRSIDEBUG
  459.     printf("drtx_defer - BACKOFFn");
  460. #endif
  461.     hp->txppersist++;
  462.     dr_wake (hp, TX, tx_fsm, hp->slotime);
  463.     return;
  464. }
  465. /* No backoff - set RTS and start to transmit frame */
  466. write_scc(base, R1, 0); /* Prevent external status int */
  467. write_scc(base, R3, Rx8); /* Turn Rx off */
  468. hp->rstate = IDLE; /* Mark Rx as idle */
  469. hp->tstate = RRTS;
  470. hp->tx_state = drtx_rrts;
  471. #ifdef DRSIDEBUG
  472. printf("drtx_defer - wake posted for drtx_rrtsn");
  473. #endif
  474. write_scc(base, R9, 0); /* Interrupts off */
  475. write_scc(base,R5,RTS|Tx8|DTR); /* Turn tx on */
  476. dr_wake(hp, TX, tx_fsm, 10);
  477. }
  479. /* drtx_rrts
  480.  * Transmit RRTS state processor
  481.  */
  482. static void
  483. drtx_rrts(hp)
  484. struct drchan *hp;
  485. {
  486. register uint16 base = hp->base;
  488. write_scc(base, R9, 0); /* Interrupts off */
  489. write_scc(base,R5,TxCRC_ENAB|RTS|TxENAB|Tx8|DTR); /* Tx now on */
  490. hp->tstate = TFIRST;
  491. hp->tx_state = drtx_tfirst;
  492. #ifdef DRSIDEBUG
  493. printf("8530 Int status %xn", read_scc(base+CHANA,R3)); 
  494. printf("drtx_rrts - Wake posted for TXDELAYn");
  495. #endif
  496. dr_wake(hp, TX, tx_fsm, hp->txdelay);
  497. }
  498.     
  499. /* drtx_tfirst
  500.  * Transmit TFIRST state processor
  501.  */
  502. static void
  503. drtx_tfirst(hp)
  504. struct drchan *hp;
  505. {
  506. register uint16 base = hp->base;
  507. char c;
  509. /* Copy data to a local buffer to save on mbuf overheads
  510.  * during transmit interrupt time.
  511.  */
  512. hp->drtx_cnt = len_p(hp->sndbuf);
  513. hp->drtx_tcp = hp->drtx_buffer;
  515. pullup(&hp->sndbuf, hp->drtx_tcp, hp->drtx_cnt);
  517. /* Transmit the first character in the buffer */
  518. c = *hp->drtx_tcp++;
  519. hp->drtx_cnt--;
  521. write_scc(base, R0, RES_Tx_CRC); /* Reset CRC */
  522. write_scc(base, R0, RES_EOM_L); /* Reset underrun latch */
  523. outportb(base+DATA, c); /* Output first character */
  524. write_scc(base, R15, TxUIE); /* Allow underrun ints only */
  525. write_scc(base, R1, TxINT_ENAB|EXT_INT_ENAB); /* Tx/Ext status ints on */
  526. write_scc(base, R9, MIE|NV); /* master enable */
  527. hp->tstate = ACTIVE;
  528. hp->tx_state = drtx_active;
  529. }
  531. /* drtx_active
  532.  * Transmit ACTIVE state processor
  533.  */
  534. static void
  535. drtx_active(hp)
  536. struct drchan *hp;
  537. {
  538. if(hp->drtx_cnt-- > 0){
  539. /* Send next character */
  540. outportb(hp->base+DATA, *hp->drtx_tcp++);
  541. } else {
  542. /* No more to send - wait for underrun to hit */
  543. hp->tstate = UNDERRUN;
  544. hp->tx_state = drtx_flagout;
  545. free_p(&hp->sndbuf);
  546. write_scc(hp->base, R0, RES_EOM_L);  /* Send CRC on underrun */
  547. write_scc(hp->base, R0, RES_Tx_P);   /* Reset Tx Int pending */
  548. }
  549. }
  551. /* drtx_flagout
  552.  * Transmit FLAGOUT state processor
  553.  */
  554. static void
  555. drtx_flagout(hp)
  556. struct drchan *hp;
  557. {
  558. /* Arrive here after CRC sent and Tx interrupt fires.
  559.  * Post a wake for ENDDELAY
  560.  */
  562. hp->tstate = UNDERRUN;
  563. hp->tx_state = drtx_downtx;
  564. write_scc(hp->base, R9, 0);
  565. write_scc(hp->base, R0,  RES_Tx_P);
  566. dr_wake(hp, TX, tx_fsm, hp->enddelay);
  567. }
  569. /* drtx_downtx
  570.  * Transmit DOWNTX state processor
  571.  */
  572. static void
  573. drtx_downtx(hp)
  574. struct drchan *hp;
  575. {
  576. register int base = hp->base;
  578. /* See if theres anything left to send - if there is,  send it ! */
  579. if((hp->sndbuf = dequeue(&hp->sndq)) == NULL){
  580. /* Nothing left to send - return to receive */
  581. write_scc(base, R5, Tx8|DTR);   /* Tx off now */
  582. write_scc(base, R0, ERR_RES);   /* Reset error bits */
  583. hp->tstate = IDLE;
  584. hp->tx_state = drtx_idle;
  585. hp->rstate = ENABLE;
  586. hp->rx_state = drrx_enable;
  587. drrx_enable(hp);
  588. } else
  589. drtx_tfirst(hp);
  591. }
  592.     
  593. /* Write CTC register */
  594. static void
  595. write_ctc(base, reg, val)
  596. uint16 base;
  597. uint8 reg,val;
  598. {
  599. int i_state;
  601. i_state = dirps();
  602. /* Select register */
  603. outportb(base+Z8536_MASTER,reg);
  604. outportb(base+Z8536_MASTER,val);
  605. restore(i_state);
  606. }
  608. /* Read CTC register */
  609. static char
  610. read_ctc(base, reg)
  611. uint16 base;
  612. uint8 reg;
  613. {
  614. uint8 c;
  615. uint16 i;
  616. int i_state;
  618. i_state = dirps();
  619. /* Select register */
  620.         outportb(base+Z8536_MASTER,reg);
  621. /* Delay for a short time to allow 8536 to settle */
  622. for(i=0;i<100;i++)
  623. ;
  624. c = inportb(base+Z8536_MASTER);
  625. restore(i_state);
  626. return(c);
  627. }
  629. /* Initialize dr controller parameters */
  630. static int
  631. drchanparam(hp)
  632. register struct drchan *hp;
  633. {
  634. uint16 tc;
  635. long br;
  636. register uint16 base;
  637. int i_state;
  639. /* Initialize 8530 channel for SDLC operation */
  640. base = hp->base;
  641. i_state = dirps();
  643. switch(base & 2){
  644. case 2:
  645. write_scc(base,R9,CHRA); /* Reset channel A */
  646. break;
  647. case 0:
  648. write_scc(base,R9,CHRB); /* Reset channel B */
  649. break;
  650. }
  651. /* Deselect all Rx and Tx interrupts */
  652. write_scc(base,R1,0);
  654. /* Turn off external interrupts (like CTS/CD) */
  655. write_scc(base,R15,0);
  657. /* X1 clock, SDLC mode */
  658. write_scc(base,R4,SDLC|X1CLK);  /* SDLC mode and X1 clock */
  660. /* Now some misc Tx/Rx parameters */
  661. /* CRC PRESET 1, NRZI Mode */
  662. write_scc(base,R10,CRCPS|NRZI);
  664. /* Set up BRG and DPLL multiplexers */
  665. /* Tx Clk from RTxC. Rcv Clk from DPLL, TRxC pin outputs BRG */
  666. write_scc(base,R11,RCDPLL|TCRTxCP|TRxCOI|TRxCBR);
  668. /* Null out SDLC start address */
  669. write_scc(base,R6,0);
  671. /* SDLC flag */
  672. write_scc(base,R7,FLAG);
  674. /* Set up the Transmitter but don't enable it */
  675. /*  DTR, 8 bit TX chars only - TX NOT ENABLED */
  676. write_scc(base,R5,Tx8|DTR);
  678. /* Receiver - initial setup only - more later */
  679. write_scc(base,R3,Rx8);  /* 8 bits/char */
  681. /* Setting up BRG now - turn it off first */
  682. write_scc(base,R14,BRSRC);     /* BRG off, but keep Pclk source */
  684. /* set the 32x time constant for the BRG */
  686. br = hp->speed; /* get desired speed */
  687. tc = ((XTAL/32)/br)-2; /* calc 32X BRG divisor */
  689. write_scc(base,R12,tc);      /* lower byte */
  690. write_scc(base,R13,(tc>>8)); /* upper bite */
  692. /* Time to set up clock control register for RECEIVE mode
  693.  * DRSI has xtal osc going to pclk at 4.9152 Mhz
  694.  * The BRG is sourced from that, and set to 32x clock
  695.  * The DPLL is sourced from the BRG.  BRG is fed to the TRxC pin
  696.  * Transmit clock is provided by the BRG externally divided by
  697.  * 32 in the CTC counter 1 and 2.
  698.  * Receive clock is from the DPLL
  699.  */
  701. /* Following subroutine sets up and ENABLES the receiver */
  702. drrx_enable(hp);
  704. /* DPLL from BRG, BRG source is PCLK */
  705. write_scc(hp->base,R14,BRSRC|SSBR);
  706. /* SEARCH mode, keep BRG source */
  707. write_scc(hp->base,R14,BRSRC|SEARCH);
  708. /* Enable the BRG */
  709. write_scc(hp->base,R14,BRSRC|BRENABL);
  711. /* enable the receive interrupts */
  713. write_scc(hp->base,R1,(INT_ALL_Rx|EXT_INT_ENAB));
  714. write_scc(hp->base,R15,BRKIE); /* ABORT int */
  715. write_scc(hp->base,R9,MIE|NV); /* master enable */
  718. /* Now, turn on the receiver and hunt for a flag */
  719. write_scc(hp->base,R3,RxENABLE|RxCRC_ENAB|Rx8);
  721. restore(i_state);
  722. return 0;
  723. }
  725. /*
  726.  * Initialize the CTC (8536)
  727.  * Only the counter/timers are used - the IO ports are un-comitted.
  728.  * Channels 1 and 2 are linked to provide a /32 counter to convert
  729.  * the SIO BRG to a real clock for Transmit clocking.
  730.  * CTC 3 is left free running on a 10 mS period.  It is always polled
  731.  * and therefore all interrupts from the chip are disabled.
  732.  *
  733.  * Updated 02/16/89 by N6TTO
  734.  * Changed to support the use of the second channel on the 8530.
  735.  * Added so that the driver works on the DRSI type 2 PC Adaptor
  736.  * which has 2 1200 bps modems.
  737.  *
  738.  */
  739. static void
  740. drinitctc(port)
  741. unsigned port;
  742. {
  743. long i;
  745. /* Initialize 8536 CTC */
  747. /* Initialize 8536 */
  748. /* Start by forcing chip into known state */
  749. (void) read_ctc(port, Z8536_MICR);
  751. write_ctc(port, Z8536_MICR, 0x01); /* Reset the CTC */
  752. for(i=0;i < 1000L; i++) /* Loop to delay */
  753. ;
  754. write_ctc(port, Z8536_MICR, 0x00); /* Clear reset and start init seq. */
  756. /* Wait for chip to come ready */
  757. while((read_ctc(port, Z8536_MICR)) != 0x02)
  758. ;
  760. write_ctc(port, Z8536_MICR, 0xa6); /* MIE|NV|CT_VIS|RJA */
  761. write_ctc(port, Z8536_MCCR, 0xf4); /* PBE|CT1E|CT2E|CT3E|PAE */
  763. write_ctc(port, Z8536_CTMS1, 0xe2); /* Continuous,EOE,ECE, Pulse output */
  764. write_ctc(port, Z8536_CTMS2, 0xe2); /* Continuous,EOE,ECE, Pulse output */
  765. write_ctc(port, Z8536_CTMS3, 0x80); /* Continuous,Pulse output */
  766. write_ctc(port, Z8536_CT1MSB, 0x00); /* Load time constant CTC #1 */
  767. write_ctc(port, Z8536_CT1LSB, 0x10);
  768. write_ctc(port, Z8536_CT2MSB, 0x00); /* Load time constant CTC #2 */
  769. write_ctc(port, Z8536_CT2LSB, 0x10);
  770. write_ctc(port, Z8536_CT3MSB, 0x60); /* Load time constant CTC #3 */
  771. write_ctc(port, Z8536_CT3LSB, 0x00);
  773. write_ctc(port, Z8536_IVR, 0x06);
  775. /* Set port direction bits in port A and B
  776.  * Data is input on bits d1 and d5, output on d0 and d4.
  777.  * The direction is set by 1 for input and 0 for output
  778.  */
  779. write_ctc(port, Z8536_PDCA, 0x22);
  780. write_ctc(port, Z8536_PDCB, 0x22);
  782. write_ctc(port, Z8536_CSR1, Z_GCB|Z_TCB);  /* Start CTC #1 running */
  783. write_ctc(port, Z8536_CSR2, Z_GCB|Z_TCB);  /* Start CTC #2 running */
  784. write_ctc(port, Z8536_CSR3, Z_IE|Z_GCB|Z_TCB); /* Start CTC #3 running */
  785. }
  787. /* Attach a DRSI interface to the system
  788.  * argv[0]: hardware type, must be "drsi"
  789.  * argv[1]: I/O address, e.g., "0x300"
  790.  * argv[2]: vector, e.g., "2"
  791.  * argv[3]: mode, must be "ax25"
  792.  * argv[4]: iface label, e.g., "dr0"
  793.  * argv[5]: receiver packet buffer size in bytes
  794.  * argv[6]: maximum transmission unit, bytes
  795.  * argv[7]: iface speed for channel A
  796.  * argv[8]: iface speed for channel B (defaults to same as A if absent)
  797.  * argv[9]: First IP address, optional (defaults to Ip_addr)
  798.  * argv[10]: Second IP address, optional (defaults to Ip_addr)
  799.  */
  800. int
  801. dr_attach(argc,argv)
  802. int argc;
  803. char *argv[];
  804. {
  805. register struct iface *if_pca,*if_pcb;
  806. struct drchan *hp;
  807. int dev;
  808. char *cp;
  810. /* Quick check to make sure args are good and mycall is set */
  811. if(setencap(NULL,argv[3]) == -1){
  812. printf("Mode %s unknown for interface %sn",
  813. argv[3],argv[4]);
  814. return -1;
  815. }
  816. if(if_lookup(argv[4]) != NULL){
  817. printf("Interface %s already existsn", argv[4]);
  818. return -1;
  819. }
  820. if(Mycall[0] == ''){
  821. printf("set mycall firstn");
  822. return -1;
  823. }
  824. /* Note: More than one card can be supported if you give up a COM:
  825.  * port, thus freeing up an IRQ line and port address
  826.  */
  827. if(Drnbr >= DRMAX){
  828. printf("Only %d DRSI controller(s) supported right now!n",DRMAX);
  829. return -1;
  830. }
  831. dev = Drnbr++;
  833. /* Initialize hardware-level control structure */
  834. Drsi[dev].addr = htoi(argv[1]);
  835. Drsi[dev].vec = atoi(argv[2]);
  836. if(strchr(argv[2],'c') != NULL)
  837. Drsi[dev].chain = 1;
  838. else
  839. Drsi[dev].chain = 0;
  841. /* Save original interrupt vector */
  842. Drsi[dev].oldvec = getirq(Drsi[dev].vec);
  844. /* Set new interrupt vector */
  845. if(setirq(Drsi[dev].vec,Drhandle[dev]) == -1){
  846. printf("IRQ %u out of rangen",Drsi[dev].vec);
  847. Drnbr--;
  848. }
  849. /* Initialize the CTC */
  850. drinitctc(Drsi[dev].addr);
  852. /* Create iface structures and fill in details */
  853. if_pca = (struct iface *)callocw(1,sizeof(struct iface));
  854. if_pcb = (struct iface *)callocw(1,sizeof(struct iface));
  856. if_pca->addr = if_pcb->addr = Ip_addr;
  857. if(argc > 9)
  858. if_pca->addr = resolve(argv[9]);
  859. if(argc > 10)
  860. if_pcb->addr = resolve(argv[10]);
  861. if(if_pca->addr == 0 || if_pcb->addr == 0){
  862. printf(Noipaddr);
  863. free(if_pca);
  864. free(if_pcb);
  865. return -1;
  866. }
  867. /* Append "a" to iface associated with A channel */
  868. if_pca->name = mallocw((unsigned)strlen(argv[4])+2);
  869. strcpy(if_pca->name,argv[4]);
  870. strcat(if_pca->name,"a");
  872. /* Append "b" to iface associated with B channel */
  873. if_pcb->name = mallocw((unsigned)strlen(argv[4])+2);
  874. strcpy(if_pcb->name,argv[4]);
  875. strcat(if_pcb->name,"b");
  877. if_pcb->mtu = if_pca->mtu = atoi(argv[6]);
  878. if_pcb->ioctl = if_pca->ioctl = dr_ctl;
  879. if_pca->dev = 2*dev; /* dr0a */
  880. if_pcb->dev = 2*dev + 1; /* dr0b */
  881. if_pcb->stop = if_pca->stop = dr_stop;
  882. if_pcb->raw = if_pca->raw = dr_raw;
  884. setencap(if_pca,argv[3]);
  885. setencap(if_pcb,argv[3]);
  886. if(if_pcb->hwaddr == NULL)
  887. if_pcb->hwaddr = mallocw(sizeof(Mycall));
  888. memcpy(if_pcb->hwaddr,&Mycall,sizeof(Mycall));
  889. if(if_pca->hwaddr == NULL)
  890. if_pca->hwaddr = mallocw(sizeof(Mycall));
  891. memcpy(if_pca->hwaddr,&Mycall,sizeof(Mycall));
  892. /* Link em in to the iface chain */
  893. if_pca->next = if_pcb;
  894. if_pcb->next = Ifaces;
  895. Ifaces = if_pca;
  897. /* set params in drchan table for CHANNEL B */
  899. hp = &Drchan[2*dev+1]; /* dr1 is offset 1 */
  900. hp->iface = if_pcb;
  901. hp->stata = Drsi[dev].addr + CHANA + CTL; /* permanent status */
  902. hp->statb = Drsi[dev].addr + CHANB + CTL; /* addrs for CHANA/B*/
  903. if(argc > 8){
  904. /* Separate speed for channel B */
  905. hp->speed = (uint16)atoi(argv[8]);
  906. } else {
  907. /* Set speed to same as for channel A */
  908. hp->speed = (uint16)atoi(argv[7]);
  909. }
  910. hp->base = Drsi[dev].addr + CHANB;
  911. hp->bufsiz = atoi(argv[5]);
  912. hp->drtx_buffer = mallocw(if_pcb->mtu+100);
  913. hp->tstate = IDLE;
  914. hp->tx_state = drtx_idle;
  915. hp->w[RX].wcall = NULL;
  916. hp->w[RX].wakecnt = 0;
  917. hp->w[TX].wcall = NULL;
  918. hp->w[TX].wakecnt = 0;
  919. /* default KISS Params */
  920. hp->txdelay = 25; /* 250 Ms */
  921. hp->persist = 64; /* 25% persistence */
  922. hp->slotime = 10; /* 100 Ms */
  923. hp->squeldelay = 20; /* 200 Ms */
  924. hp->enddelay = 10; /* 100 Ms */
  926. write_scc(hp->stata,R9,FHWRES); /* Hardware reset */
  928. /* Disable interrupts with Master interrupt ctrl reg */
  929. write_scc(hp->stata,R9,0);
  931. drchanparam(hp); 
  933. /* Initialize buffer pointers */
  934. hp->rcvbuf = NULL;
  935. hp->rcvbuf->cnt = 0;
  936. hp->sndq = NULL;
  938. /* set params in drchan table for CHANNEL A */
  939. hp = &Drchan[2*dev]; /* dr0a is offset 0 */
  940. hp->iface = if_pca;
  941. hp->speed = (uint16)atoi(argv[7]);
  942. hp->base = Drsi[dev].addr + CHANA;
  943. hp->bufsiz = atoi(argv[5]);
  944. hp->drtx_buffer = mallocw(if_pca->mtu+100);
  945. hp->tstate = IDLE;
  946. hp->tx_state = drtx_idle;
  947. hp->w[RX].wcall = NULL;
  948. hp->w[RX].wakecnt = 0;
  949. hp->w[TX].wcall = NULL;
  950. hp->w[TX].wakecnt = 0;
  951. /* default KISS Params */
  952. hp->txdelay = 30; /* 300 Ms */
  953. hp->persist = 64; /* 25% persistence */
  954. hp->slotime = 10; /* 100 Ms */
  955. hp->squeldelay = 20; /* 200 Ms */
  956. hp->enddelay = 10; /* 100 Ms */
  958. drchanparam(hp);
  960. /* Initialize buffer pointers */
  961. hp->rcvbuf = NULL;
  962. hp->rcvbuf->cnt = 0;
  963. hp->sndq = NULL;
  965. write_scc(hp->base,R9,MIE|NV); /* master interrupt enable */
  967. /* Enable interrupt in 8259 interrupt controller */
  968. maskon(Drsi[dev].vec);
  970. cp = if_name(if_pca," tx");
  971. if_pca->txproc = newproc(cp,512,if_tx,0,if_pca,NULL,0);
  972. free(cp);
  973. cp = if_name(if_pcb," tx");
  974. if_pcb->txproc = newproc(cp,512,if_tx,0,if_pcb,NULL,0);
  975. free(cp);
  976. return 0;
  977. }
  979. /* Shut down iface */
  980. static int
  981. dr_stop(iface)
  982. struct iface *iface;
  983. {
  984. uint16 dev;
  986. dev = iface->dev;
  987. if(dev & 1)
  988. return 0;
  989. dev >>= 1; /* Convert back into DRSI number */
  991. /* Set 8259 interrupt mask (turn off interrupts) */
  992. maskoff(Drsi[dev].vec);
  994. /* Restore original interrupt vector */
  995. setirq(Drsi[dev].vec, Drsi[dev].oldvec);
  996. Drnbr--;
  998. /* Force hardware reset */
  999. write_scc(Drsi[dev].addr + CHANA + CTL,R9,FHWRES);
  1000. /* Reset the CTC */
  1001. (void) read_ctc(Drsi[dev].addr, Z8536_MICR);
  1002. write_ctc(Drsi[dev].addr, Z8536_MICR, 0x01);
  1003. return 0;
  1004. }
  1006. /* Send raw packet on DRSI card */
  1007. static int
  1008. dr_raw(
  1009. struct iface *iface,
  1010. struct mbuf **bpp
  1011. ){
  1012. char kickflag;
  1013. struct drchan *hp;
  1014. int i_state;
  1016. dump(iface,IF_TRACE_OUT,*bpp);
  1017. iface->rawsndcnt++;
  1018. iface->lastsent = secclock();
  1020. hp = &Drchan[iface->dev];
  1021. i_state = dirps();
  1022. kickflag = (hp->sndq == NULL) & (hp->sndbuf == NULL);
  1023. /* clever! flag=1 if something in queue */
  1024. enqueue(&hp->sndq,bpp);
  1026. if(kickflag) /* simulate interrupt to xmit */
  1027. tx_fsm(hp); /* process interrupt */
  1029. restore(i_state);
  1030. return 0;
  1031. }
  1033. /* display DRSI Channel stats */
  1034. int
  1035. dodrstat(argc,argv,p)
  1036. int argc;
  1037. char *argv[];
  1038. void *p;
  1039. {
  1040. struct drchan *hp0, *hp1;
  1041. int i;
  1043. for(i=0; i<DRMAX; i++){
  1044. hp0 = &Drchan[i];
  1045. hp1 = &Drchan[i+1];
  1046. i = Drchan[i].base;
  1047. printf("DRSI Board Statistics - N6TTO 112790.0n");
  1048. printf("--------------------------------------n");
  1049. printf("Channel - %sn", hp0->iface->name);
  1050. printf("Rxints  - %8ld  Txints  - %8ld  Exints  - %8ldn",
  1051. hp0->rxints, hp0->txints, hp0->exints);
  1052. printf("Enqued  - %8ld  Crcerr  - %8ld  Aborts  - %8ldn",
  1053. hp0->enqueued, hp0->crcerr, hp0->aborts);
  1054. printf("RFrames - %8ld  Rxovers - %8ld  TooBig  - %8ldn",
  1055. hp0->rxframes, hp0->rovers, hp0->toobig);
  1056. printf("Txdefer - %8ld  Txppers - %8ld  Nomem   - %8ldn",
  1057. hp0->txdefers, hp0->txppersist, hp0->nomem);
  1058. printf("Tx state  %8d  Rx state  %8dnn",hp0->tstate,hp0->rstate);
  1059. printf("Channel - %sn", hp1->iface->name);
  1060. printf("Rxints  - %8ld  Txints  - %8ld  Exints  - %8ldn",
  1061. hp1->rxints, hp1->txints, hp1->exints);
  1062. printf("Enqued  - %8ld  Crcerr  - %8ld  Aborts  - %8ldn",
  1063. hp1->enqueued, hp1->crcerr, hp1->aborts);
  1064. printf("RFrames - %8ld  Rxovers - %8ld  TooBig  - %8ldn",
  1065. hp1->rxframes, hp1->rovers, hp1->toobig);
  1066. printf("Txdefer - %8ld  Txppers - %8ld  Nomem   - %8ldn",
  1067. hp1->txdefers, hp1->txppersist, hp1->nomem);
  1068. printf("Tx state  %8d  Rx state  %8dn",hp1->tstate,hp1->rstate);
  1069. }
  1070. return 0;
  1071. }
  1073. /* Subroutine to set kiss params in channel tables */
  1074. static int32
  1075. dr_ctl(iface,cmd,set,val)
  1076. struct iface *iface;
  1077. int cmd;
  1078. int set;
  1079. int32 val;
  1080. {
  1081. struct drchan *hp;
  1082. hp = &Drchan[iface->dev];
  1084. switch(cmd){
  1085. case PARAM_TXDELAY:
  1086. if(set)
  1087. hp->txdelay = val;
  1088. return hp->txdelay;
  1089. case PARAM_PERSIST:
  1090. if(set)
  1091. hp->persist = val;
  1092. return hp->persist;
  1093. case PARAM_SLOTTIME:
  1094. if(set)
  1095. hp->slotime = val;
  1096. return hp->slotime;
  1097. case PARAM_TXTAIL:
  1098. if(set)
  1099. hp->squeldelay = val;
  1100. return hp->squeldelay;
  1101. case PARAM_ENDDELAY:
  1102. if(set)
  1103. hp->enddelay = val;
  1104. return hp->enddelay;
  1105. case PARAM_SPEED:
  1106. return hp->speed;
  1107. }
  1108. return -1;
  1109. }