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

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

TCP/IP协议栈

开发平台：

Visual C++

scc.c：源码内容
  1. /* Generic driver for Z8530 boards, modified from the PE1CHL
  2.  * driver for use with NOS. This version also supports the NRS
  3.  * mode when used as an asynch port. Device setup is similar to
  4.  * that of the PE1CHL version, with the addition of user specification
  5.  * of buffer size (bufsize). See the file "scc.txt" for general
  6.  * information on the use of this driver and setup procedures.
  7.  *
  8.  * General differences between this driver and the original version:
  9.  *
  10.  * 1) Slip encoding and decoding is not done in the driver, but
  11.  *    using the routines in slip.c, and these routines are supported
  12.  *    in a manner similar to the asynch routines for the 8250. The
  13.  *    input is handled via fifo buffer, while output is direct. The
  14.  *    routines scc_send and get_scc are called via pointers in the
  15.  *    Slip and Nrs structs for the parcticular channel.
  16.  *
  17.  * 2) The timer routine, scctim, is not installed directly in the
  18.  *    timer interrupt chain, but is called through the systick routine
  19.  *    in pc.c.
  20.  *
  21.  * 3) Facilities of nos are used whenever possible in place of direct
  22.  *    structure or variable manipulation. Mbuf management is handled
  23.  *    this way, along with interface initialization.
  24.  *
  25.  * 4) Nrs mode support is added in a manner similar to that of the
  26.  *    Slip support. I have not had an opportunity to test this, but
  27.  *    it is essentially identical to the way the 8250 version works.
  28.  *
  29.  * 5) Callsign specification on radio modes (kiss,nrs,ax25) is an
  30.  *    option. If not supplied, the value of Mycall will be used.
  31.  *
  32.  * 6) Bufsize specification is now a parameter on setup of each channel.
  33.  *    This is the size of the fifo on asynch input, and the size of
  34.  *    mbuf buffers for sdlc mode. Since the fifo buffer can fill up,
  35.  *    this value should be reasonably large for asynch mode. Mbufs
  36.  *    are chained when they fill up, so having a small bufsize with
  37.  *    sdlc modes (ax25) does not result in loss of characters.
  38.  *
  39.  * 7) Because slip and nrs decoding is handled outside the driver,
  40.  *    sccstat cannot be used to report sent and receive packet counts
  41.  *    in asynch mode, and these fields are blanked on display in asynch
  42.  *    modes.
  43.  *
  44.  *
  45.  * I am interested in setting up some default initializations for
  46.  * the popular Z8530 boards, to minimize user problems in constructing
  47.  * the proper attach init entries. These would allow for shortened
  48.  * entries to use the defaults, such as "attach scc 1 init drsi" to
  49.  * attach a DRSI board in standard configuration at its default address.
  50.  * Since I do not have complete technical information on all such boards,
  51.  * I would very much appreciate any information that users can provide
  52.  * me regarding particular boards.
  53.  *
  54.  * 1/25/90
  55.  *
  56.  * Modifications:
  57.  *
  58.  * 2/17/90:
  59.  *
  60.  * 1) Added mods from PE1CHL which reflect relevent changes to the
  61.  *    scc driver in his version of net between 10/89 and 1/90. Changes
  62.  *    incorporated include additional delays in sccvec.asm, addition
  63.  *    of external clock mode, and initialization for the 8536 as a
  64.  *    clock divider on the DRSI board. "INLINE" is a slight delay
  65.  *    for register access incorporated for use with the inline i/o
  66.  *    code in MSC. This may not be useful or necessary with TURBO.
  67.  *    Changes making "TPS" a variable were not added, since the
  68.  *    scc timer does not install itself on the hardware interrupt
  69.  *    in this version.
  70.  * 
  71.  *
  72.  * Ken Mitchum, KY3B       km@cs.pitt.edu  km@dsl.pitt.edu
  73.  *                             or mail to the tcpip group
  74.  *
  75.  * 5 Aug 91:
  76.  * Support added for Sealevel Systems Inc's ACB-IV 8530 card (HWSEALEVEL)
  77.  * <hdwe> == HWSEALEVEL (0x10) sets the control/status port at chipbase + 4
  78.  * to the value in <param>. (Where the control bits for both side's DTR
  79.  * lines are; the 8530-internal DTR/REQB is used for DMA...)
  80.  *
  81.  * Added a side-effect to ATTACH SCC's <speed> == 'ext'. Previously, all 
  82.  * async modes set a 16X clock; now when external clock is selected, the 
  83.  * baud rate divider in R4 is set to 1X.
  84.  *
  85.  * Tom Jennings, Cygnus Support (tomj@cygnus.com) 
  86.  *
  87.  *
  88.  * 9 Aug 91:
  89.  * Allow 'v' to specify Van Jacobson TCP header compression (SLIP only).
  90.  * Because the 8th arg is optional [<call>], this checks for 'v' in the
  91.  * 9th arg if that exists, otherwise the 8th arg is used. Not pretty
  92.  * but servicable.
  93.  *
  94.  * Tom Jennings, Cygnus Support (tomj@cygnus.com) 
  95.  */
  97. /* Added ANSI-style prototypes, reformatted source, minor delinting.
  98.  * Integrated into standard 900201 NOS by KA9Q.
  99.  */
  101. /*
  102.  * Generic driver for Z8530 SCC chip in SLIP, KISS or AX.25 mode.
  103.  *
  104.  * Written by R.E. Janssen (PE1CHL) using material from earlier
  105.  * EAGLE and PC100 drivers in this package.
  106.  *
  107.  * The driver has initially been written for my own Atari SCC interface
  108.  * board, but it could eventually replace the other SCC drivers.
  109.  *
  110.  * Unfortunately, there is little consistency between the different interface
  111.  * boards, as to the use of a clock source, the solution for the fullduplex
  112.  * clocking problem, and most important of all: the generation of the INTACK
  113.  * signal. Most designs do not even support the generation of an INTACK and
  114.  * the read of the interrupt vector provided by the chip.
  115.  * This results in lots of configuration parameters, and a fuzzy
  116.  * polltable to be able to support multiple chips connected at one interrupt
  117.  * line...
  118.  *
  119.  */
  122. #include <stdlib.h>
  123. #include <stdio.h>
  124. #include <ctype.h>
  125. #include <time.h>
  126. #include <dos.h>
  127. #include "global.h"
  128. #include "mbuf.h"
  129. #include "config.h"
  130. #include "netuser.h"
  131. #include "proc.h"
  132. #include "iface.h"
  133. #include "pktdrvr.h"
  134. #include "slip.h"
  135. #include "nrs.h"
  136. #include "n8250.h"
  137. #include "scc.h"
  138. #include "z8530.h"
  139. #include "z8536.h"
  140. #include "ax25.h"
  141. #include "trace.h"
  142. #include "nospc.h"
  143. #include "kiss.h"
  144. #include "devparam.h"
  146. /* interrupt handlers */
  147. extern INTERRUPT sccvec();
  148. extern INTERRUPT sccnovec();
  150. /* variables used by the SCC interrupt handler in sccvec.asm */
  151. static INTERRUPT (*Orgivec)(); /* original interrupt vector */
  153. struct sccinfo Sccinfo = {0}; /* global info about SCCs */
  154. struct sccchan *Sccchan[2 * MAXSCC] = {0}; /* information per channel */
  155. ioaddr Sccvecloc = {0}; /* location to access for SCC vector */
  156. unsigned char Sccmaxvec = {0}; /* maximum legal vector from SCC */
  157. ioaddr Sccpolltab[MAXSCC+1][2] = {0}; /* polling table when no vectoring */
  159. #if defined(INLINE)
  160. static unsigned scc_delay(unsigned v);
  162. static unsigned scc_delay (v) /* delay for about 5 PCLK cycles */
  163.    unsigned v; /* pass-through used for input */
  165. {
  166.    register int i,j; /* it takes time to save them */
  168.    return v; /* return the passed parameter */
  169. }
  170. #endif
  172. unsigned char Random = 0; /* random number for p-persist */
  174. static int scc_call(struct iface *ifp,char *call);
  175. static int scc_init(int nchips,ioaddr iobase,int space,int aoff,
  176.  int boff,int doff,ioaddr intack,int ivec,long clk,int pclk,int hwtype,
  177.  int hwparam);
  178. static int scc_raw(struct iface *ifp,struct mbuf **bpp);
  179. static int scc_stop(struct iface *ifp);
  180. static int get_scc(int dev);
  181. static int scc_send(int dev,struct mbuf **bpp);
  182. static int scc_async(struct sccchan *scc);
  184. static void scc_sdlc(struct sccchan *scc);
  185. static void scc_tossb(struct sccchan *scc);
  186. static void scc_txon(struct sccchan *scc);
  187. static void scc_txoff(struct sccchan *scc);
  188. static int32 scc_aioctl(struct iface *ifp,int cmd,int set,int32 val);
  189. static int32 scc_sioctl(struct iface *ifp,int cmd,int set,int32 val);
  190. static void scc_sstart(struct sccchan *scc);
  191. static unsigned int scc_speed(struct sccchan *scc,
  192.   unsigned int clkmode,long speed);
  193. static void scc_asytx(struct sccchan *scc);
  194. static void scc_asyex(struct sccchan *scc);
  195. static void scc_asyrx(struct sccchan *scc);
  196. static void scc_asysp(struct sccchan *scc);
  197. static void scc_sdlctx(struct sccchan *scc);
  198. static void scc_sdlcex(struct sccchan *scc);
  199. static void scc_sdlcrx(struct sccchan *scc);
  200. static void scc_sdlcsp(struct sccchan *scc);
  202. /* Attach an SCC channel to the system, or initialize SCC driver.
  203.  * operation depends on argv[2]:
  204.  * when "init", the SCC driver is initialized, and global information about
  205.  * the hardware is set up.
  206.  * argv[0]: hardware type, must be "scc"
  207.  * argv[1]: number of SCC chips we will support
  208.  * argv[2]: mode, must be: "init" in this case
  209.  * argv[3]: base address of SCC chip #0 (hex)
  210.  * argv[4]: spacing between SCC chip base addresses
  211.  * argv[5]: offset from chip base address to channel A control register
  212.  * argv[6]: offset from chip base address to channel B control register
  213.  * argv[7]: offset from each channel's control register to data register
  214.  * argv[8]: address of INTACK/Read Vector port. 0 to read from RR3A/RR2B
  215.  * argv[9]: CPU interrupt vector number for all connected SCCs
  216.  * argv[10]: clock frequency (PCLK/RTxC) of all SCCs in cycles per second
  217.  *  prefix with "p" for PCLK, "r" for RTxC clock (for baudrate gen)
  218.  * argv[11]: optional hardware type (for special features)
  219.  * argv[12]: optional extra parameter for special hardware
  220.  *
  221.  * otherwise, a single channel is attached using the specified parameters:
  222.  * argv[0]: hardware type, must be "scc"
  223.  * argv[1]: SCC channel number to attach, 0/1 for first chip A/B, 2/3 for 2nd...
  224.  * argv[2]: mode, can be:
  225.  * "slip", "kiss", "ax25"
  226.  * argv[3]: interface label, e.g., "sl0"
  227.  * argv[4]: maximum transmission unit, bytes
  228.  * argv[5]: interface speed, e.g, "1200". prefix with "d" when an external
  229.  * divider is available to generate the TX clock. When the clock
  230.  * source is PCLK, this can be a /32 divider between TRxC and RTxC.
  231.  * When the clock is at RTxC, the TX rate must be supplied at TRxC.
  232.  * This is needed only for AX.25 fullduplex.
  233.  *     When this arg is given as "ext", the transmit and receive clock
  234.  *     are external, and the BRG and DPLL are not used.
  235.  * argv[6]: buffer size
  236.  * argv[7]: callsign used on the radio channels (optional) or 'v' to 
  237.  *          specify Van Jacobson TCP header compression. See argv[8] below.
  238.  * argv[8]: 'v' here specifies Van Jacobson TCP header compression iff
  239.  *          there is a 9th arg (ie. [7] is a callsign.)
  240.  */
  242. int
  243. scc_attach(argc,argv)
  244. int argc;
  245. char *argv[];
  246. {
  247. register struct iface *ifp;
  248. struct sccchan *scc;
  249. unsigned int chan,brgrate;
  250. int pclk = 0,hwtype = 0,hwparam = 0;
  251. int xdev;
  252. char *cp;
  254. /* first handle the special "init" mode, to initialize global stuff */
  256. if(!strcmp(argv[2],"init")){
  257. if(argc < 11) /* need at least argv[1]..argv[10] */
  258. return -1;
  260. if(isupper(argv[10][0]))
  261. argv[10][0] = tolower(argv[10][0]);
  263. if(argv[10][0] == 'p'){ /* wants to use PCLK as clock? */
  264. pclk = 1;
  265. argv[10]++;
  266. } else {
  267. if(argv[10][0] == 'r') /* wants to use RTxC? */
  268. argv[10]++; /* that's the default */
  269. }
  270. if(argc > 11) /* optional hardware type */
  271. hwtype = htoi(argv[11]); /* it is given in hex */
  273. if(argc > 12) /* optional hardware param */
  274. hwparam = htoi(argv[12]); /* also in hex */
  276. return scc_init(atoi(argv[1]),(ioaddr) htol(argv[3]),atoi(argv[4]),
  277. atoi(argv[5]),atoi(argv[6]),atoi(argv[7]),
  278. (ioaddr) htol(argv[8]),atoi(argv[9]),
  279. atol(argv[10]),pclk,hwtype,hwparam);
  280. }
  281. /* not "init", so it must be a valid mode to attach a channel */
  282. if(strcmp(argv[2],"ax25") && strcmp(argv[2],"kiss") &&
  283.  strcmp(argv[2],"slip")){
  284. printf("Mode %s unknown for SCCn",argv[2]);
  285. return -1;
  286. }
  287. if(strcmp(argv[2],"slip") == 0 || strcmp(argv[2],"kiss") == 0){
  288. for(xdev = 0;xdev < SLIP_MAX;xdev++)
  289. if(Slip[xdev].iface == NULL)
  290. break;
  291. if(xdev >= SLIP_MAX){
  292. printf("Too many slip devicesn");
  293. return -1;
  294. }
  295. }
  296. if(strcmp(argv[2],"nrs") == 0){
  297. for(xdev = 0;xdev < NRS_MAX;xdev++)
  298. if(Nrs[xdev].iface == NULL)
  299. break;
  301. if(xdev >= NRS_MAX){
  302. printf("Too many nrs devicesn");
  303. return -1;
  304. }
  305. }
  306. if(!Sccinfo.init){
  307. printf("First init SCC drivern");
  308. return -1;
  309. }
  310. if((chan = atoi(argv[1])) > Sccinfo.maxchan){
  311. printf("SCC channel %d out of rangen",chan);
  312. return -1;
  313. }
  314. if(Sccchan[chan] != NULL){
  315. printf("SCC channel %d already attachedn",chan);
  316. return -1;
  317. }
  318. /* create interface structure and fill in details */
  319. ifp = (struct iface *) callocw(1,sizeof(struct iface));
  320. ifp->name = mallocw(strlen(argv[3]) + 1);
  321. strcpy(ifp->name,argv[3]);
  323. ifp->mtu = atoi(argv[4]);
  324. ifp->dev = chan;
  325. ifp->stop = scc_stop;
  327. scc = (struct sccchan *) callocw(1,sizeof(struct sccchan));
  328. scc->ctrl = Sccinfo.iobase + (chan / 2) * Sccinfo.space + Sccinfo.off[chan % 2];
  329. scc->data = scc->ctrl + Sccinfo.doff;
  330. scc->iface = ifp;
  332. if(isupper(argv[5][0]))
  333. argv[5][0] = tolower(argv[5][0]);
  335.     switch (argv[5][0]) {
  336.     case 'd': /* fulldup divider installed? */
  337. scc->fulldup = 1; /* set appropriate flag */
  338. argv[5]++; /* skip the 'd' */
  339. break;
  341.     case 'e': /* external clocking? */
  342. scc->extclock = 1; /* set the flag */
  343. break;
  344.     }
  346. scc->bufsiz = atoi(argv[6]);
  347. ifp->addr = Ip_addr; 
  348. Sccchan[chan] = scc; /* put addr in table for interrupts */
  350. switch(argv[2][0]){  /* mode already checked above */
  351. #ifdef AX25
  352. case 'a': /* AX.25 */
  353. scc_sdlc(scc); /* init SCC in SDLC mode */
  355. if (!scc->extclock) {
  356. brgrate = scc_speed(scc,32,atol(argv[5]));/* init SCC speed */
  357. scc->speed = Sccinfo.clk / (64L * (brgrate + 2));/* calc real speed */
  358. }
  360. brgrate = scc_speed(scc,32,atol(argv[5]));/* init SCC speed */
  361. scc->speed = Sccinfo.clk / (64L * (brgrate + 2));/* calc real speed */
  362. setencap(ifp,"AX25UI");
  363. scc_call(ifp,argc > 7 ? argv[7] : (char *) 0); /* set the callsign */
  364. ifp->ioctl = scc_sioctl;
  365. ifp->raw = scc_raw;
  367. /* default KISS Params */
  368. scc->a.txdelay = 36*TPS/100; /* 360 ms */
  369. scc->a.persist = 25; /* 10% persistence */
  370. scc->a.slottime = 16*TPS/100; /* 160 ms */
  371. #if TPS > 67
  372. scc->a.tailtime = 3*TPS/100; /* 30 ms */
  373. #else
  374. scc->a.tailtime = 2; /* minimal reasonable value */
  375. #endif
  376. scc->a.fulldup = 0; /* CSMA */
  377. scc->a.waittime = 50*TPS/100; /* 500 ms */
  378. scc->a.maxkeyup = 7; /* 7 s */
  379. scc->a.mintime = 3; /* 3 s */
  380. scc->a.idletime = 120; /* 120 s */
  381. break;
  382. case 'k': /* kiss */
  383. scc_async(scc); /* init SCC in async mode */
  384. brgrate = scc_speed(scc,16,atol(argv[5]));
  385. scc->speed = Sccinfo.clk / (32L * (brgrate + 2));
  387. setencap(ifp,"AX25UI");
  388. scc_call(ifp,argc > 7 ? argv[7] : (char *) 0); /* set the callsign */
  390. ifp->ioctl = kiss_ioctl;
  391. ifp->raw = kiss_raw;
  393. for(xdev = 0;xdev < SLIP_MAX;xdev++){
  394. if(Slip[xdev].iface == NULL)
  395. break;
  396. }
  397. ifp->xdev = xdev;
  398. Slip[xdev].iface = ifp;
  399. Slip[xdev].type = CL_KISS;
  400. Slip[xdev].send = scc_send;
  401. Slip[xdev].get = get_scc;
  402. cp = if_name(ifp," rx");
  403. ifp->rxproc = newproc(cp,256,slip_rx,xdev,NULL,NULL,0);
  404. free(cp);
  405. break;
  406. #endif
  407. #ifdef SLIP
  408. case 's': /* slip */
  409. scc_async(scc); /* init SCC in async mode */
  410. brgrate = scc_speed(scc,16,atol(argv[5]));
  411. scc->speed = Sccinfo.clk / (32L * (brgrate + 2));
  412. setencap(ifp,"SLIP");
  413. ifp->ioctl = scc_aioctl;
  414. ifp->raw = slip_raw;
  415. for(xdev = 0;xdev < SLIP_MAX;xdev++){
  416. if(Slip[xdev].iface == NULL)
  417. break;
  418. }
  419. ifp->xdev = xdev;
  420. Slip[xdev].iface = ifp;
  421. Slip[xdev].type = CL_SERIAL_LINE;
  422. Slip[xdev].send = scc_send;
  423. Slip[xdev].get = get_scc;
  424. cp = if_name(ifp," rx");
  426. #ifdef VJCOMPRESS
  427. if((argc > 8) && (strchr(argv[8],'v') != NULL)) {
  428. Slip[xdev].escaped |= SLIP_VJCOMPR;
  429. Slip[xdev].slcomp = slhc_init(16,16);
  431. } else if((argc > 7) && (strchr(argv[7],'v') != NULL)) {
  432. Slip[xdev].escaped |= SLIP_VJCOMPR;
  433. Slip[xdev].slcomp = slhc_init(16,16);
  434. }
  435. #else
  436. Slip[xdev].slcomp = NULL;
  437. #endif /* VJCOMPRESS */
  438. ifp->rxproc = newproc(cp,256,slip_rx,xdev,NULL,NULL,0);
  439. free(cp);
  440. break;
  441. #endif
  442. #ifdef NRS
  443. case 'n': /* nrs */
  444. scc_async(scc); /* init SCC in async mode */
  445. brgrate = scc_speed(scc,16,atol(argv[5]));
  446. scc->speed = Sccinfo.clk / (32L * (brgrate + 2));
  447. setencap(ifp,"AX25UI");
  448. scc_call(ifp,argc > 7 ? argv[7] : (char *) 0); /* set the callsign */
  449. ifp->ioctl = scc_aioctl;
  450. ifp->raw = nrs_raw;
  452. for(xdev = 0;xdev < NRS_MAX;xdev++)
  453. if(Nrs[xdev].iface == NULL)
  454. break;
  456. ifp->xdev = xdev;
  457. Nrs[xdev].iface = ifp;
  458. Nrs[xdev].send = scc_send;
  459. Nrs[xdev].get = get_scc;
  460. cp = if_name(ifp," rx");
  461. ifp->rxproc = newproc(cp,256,nrs_recv,xdev,NULL,NULL,0);
  462. free(cp);
  463. break;
  464. #endif
  465. }
  466. ifp->next = Ifaces; /* link interface in list */
  467. Ifaces = ifp;
  468. cp = if_name(ifp," tx");
  469. ifp->txproc = newproc(cp,512,if_tx,0,ifp,NULL,0);
  470. free(cp);
  471. return 0;
  472. }
  474. /* SCC driver initialisation. called on "attach scc <num> init ..." */
  475. static int
  476. scc_init(nchips,iobase,space,aoff,boff,doff,intack,ivec,clk,pclk,hwtype,hwparam)
  477. int nchips; /* number of chips */
  478. ioaddr iobase; /* base of first chip */
  479. int space,aoff,boff,doff;
  480. ioaddr intack; /* INTACK ioport or 0 for no INTACK */
  481. int ivec; /* interrupt vector number */
  482. long clk; /* clock frequency */
  483. int pclk; /* PCLK or RTxC for clock */
  484. int hwtype; /* selection of special hardware types */
  485. int hwparam; /* extra parameter for special hardware */
  486. {
  487. int chip,chan;
  488. ioaddr chipbase;
  489. register ioaddr ctrl;
  490.     int d;
  491.     int dum = 1;
  492. int i_state;
  494. #define z 0
  496. if(Sccinfo.init){
  497. printf("SCC driver already initialized - nothing donen");
  498. return 1;
  499. }
  500. Sccinfo.init = 1;
  501. Sccinfo.nchips = nchips;
  502. Sccinfo.maxchan = (2 * nchips) - 1;
  503. Sccinfo.iobase = iobase;
  504. Sccinfo.space = space;
  505. Sccinfo.off[0] = aoff;
  506. Sccinfo.off[1] = boff;
  507. Sccinfo.doff = doff;
  508. Sccinfo.ivec = ivec;
  509. Sccinfo.clk = clk;
  510. Sccinfo.pclk = pclk;
  511. Sccinfo.hwtype = hwtype;
  512. Sccinfo.hwparam = hwparam;
  514. /* reset and pre-init all chips in the system */
  515. for(chip = 0; chip < nchips; chip++){
  516. chipbase = iobase + chip * space;
  517. ctrl = chipbase + Sccinfo.off[0];
  518. i_state = dirps(); /* because of 2-step accesses */
  519. VOID(RDREG(ctrl)); /* make sure pointer is written */
  520. WRSCC(ctrl,R9,FHWRES); /* force hardware reset */
  521. for (d = 0; d < 1000; d++) /* wait a while to be sure */
  522. dum *= 10;
  523. for(chan = 0; chan < 2; chan++){
  524. ctrl = chipbase + Sccinfo.off[chan];
  526. /* initialize a single channel to no-op */
  527. VOID(RDREG(ctrl)); /* make sure pointer is written */
  528. WRSCC(ctrl,R4,z); /* no mode selected yet */
  529. WRSCC(ctrl,R1,z); /* no W/REQ operation */
  530. WRSCC(ctrl,R2,16 * chip); /* chip# in upper 4 bits of vector */
  531. WRSCC(ctrl,R3,z); /* disable rx */
  532. WRSCC(ctrl,R5,z); /* disable tx */
  533. WRSCC(ctrl,R9,VIS); /* vector includes status, MIE off */
  534. Sccpolltab[chip][chan] = ctrl; /* store ctrl addr for polling */
  535. }
  537. if (hwtype & HWSEALEVEL) /* if a SEALEVEL card, */
  538. WRREG(chipbase + 4,hwparam); /* set control/status (DTR) */
  540. if(hwtype & HWEAGLE) /* this is an EAGLE card */
  541. WRREG(chipbase + 4,0x08); /* enable interrupt on the board */
  543. if(hwtype & HWPC100) /* this is a PC100 card */
  544. WRREG(chipbase,hwparam); /* set the MODEM mode (22H normally) */
  546. if(hwtype & HWPRIMUS) /* this is a PRIMUS-PC */
  547. WRREG(chipbase + 4,hwparam); /* set the MODEM mode (02H normally) */
  549. if (hwtype & HWDRSI) { /* this is a DRSI PC*Packet card */
  550. ioaddr z8536 = chipbase + 7; /* point to 8536 master ctrl reg */
  552. /* Initialize 8536 to perform its divide-by-32 function */
  553. /* This part copied from N6TTO DRSI-driver */
  555. /* Start by forcing chip into known state */
  557. VOID(RDREG(z8536)); /* make sure pointer is written */
  558. WRSCC(z8536,CIO_MICR,0x01); /* force hardware reset */
  560. for (d = 0; d < 1000; d++) /* wait a while to be sure */
  561. dum *= 10;
  563. WRSCC(z8536,CIO_MICR,0x00); /* Clear reset and start */
  565. /* Wait for chip to come ready */
  567. while (RDSCC(z8536,CIO_MICR) != 0x02)
  568. dum *= 10;
  570. WRSCC(z8536,CIO_MICR,0x26); /* NV|CT_VIS|RJA */
  571. WRSCC(z8536,CIO_MCCR,0xf4); /* PBE|CT1E|CT2E|CT3E|PAE */
  573. WRSCC(z8536,CIO_CTMS1,0xe2);/* Continuous, EOE, ECE, Pulse output */
  574. WRSCC(z8536,CIO_CTMS2,0xe2);/* Continuous, EOE, ECE, Pulse output */
  576.     WRSCC(z8536,CIO_CT1MSB,0x00); /* Load time constant CTC #1 */
  577. WRSCC(z8536,CIO_CT1LSB,0x10);
  578. WRSCC(z8536,CIO_CT2MSB,0x00); /* Load time constant CTC #2 */
  579. WRSCC(z8536,CIO_CT2LSB,0x10);
  581. WRSCC(z8536,CIO_IVR,0x06);
  583. /* Set port direction bits in port A and B      */
  584. /* Data is input on bits d1 and d5, output on d0 and d4. */
  585. /* The direction is set by 1 for input and 0 for output  */
  587. WRSCC(z8536,CIO_PDCA,0x22);
  588. WRSCC(z8536,CIO_PDCB,0x22);
  590. WRSCC(z8536,CIO_CSR1,CIO_GCB|CIO_TCB); /* Start CTC #1 running */
  591. WRSCC(z8536,CIO_CSR2,CIO_GCB|CIO_TCB); /* Start CTC #2 running */
  592. }
  594. restore(i_state);
  595. }
  596. Sccpolltab[chip][0] = 0; /* terminate the polling table */
  597. Sccvecloc = intack; /* location of INTACK/vector read */
  598. Sccmaxvec = 16 * nchips; /* upper limit on valid vector */
  599. /* save original interrupt vector */
  600. Orgivec = getirq(ivec);
  602. if(intack){ /* INTACK method selected? */
  603. /* set interrupt vector to INTACK-generating routine  */
  604. setirq(ivec,sccvec);
  605. } else {
  606. /* set interrupt vector to polling routine */
  607. setirq(ivec,sccnovec);
  608. }
  609. /* enable the interrupt  */
  610. maskon(ivec);
  611. return 0;
  612. }
  614. /* initialize an SCC channel in asynchronous mode */
  615. static int
  616. scc_async(scc)
  617. register struct sccchan *scc;
  618. {
  619. register struct fifo *fp = &(scc->fifo);
  620. int i_state;
  622. if((fp->buf = malloc(scc->bufsiz)) == NULL){
  623. printf("scc%d: No space for rx buffern",scc->iface->dev);
  624. return -1;
  625. }
  626. fp->bufsize = scc->bufsiz;
  627. fp->wp = fp->rp = fp->buf;
  628. fp->cnt = 0;
  630. scc->int_transmit = scc_asytx; /* set interrupt handlers */
  631. scc->int_extstat = scc_asyex;
  632. scc->int_receive = scc_asyrx;
  633. scc->int_special = scc_asysp;
  635. i_state = dirps();
  637. if (scc->extclock) {
  638. wr(scc,R4,X1CLK|SB1); /* *1 clock, 1 stopbit, no parity */
  639. wr(scc,R11,RCRTxCP|TCTRxCP); /* RXclk RTxC, TXclk TRxC. */
  640. wr(scc,R14,z); /* No BRG options */
  641. wr(scc,R4,X16CLK|SB1); /* *16 clock, 1 stopbit, no parity */
  642. wr(scc,R11,RCBR|TCBR); /* clocks are BR generator */
  643. wr(scc,R14,Sccinfo.pclk? BRSRC:z); /* brg source = PCLK/RTxC */
  644. }
  645. wr(scc,R1,z); /* no W/REQ operation */
  646. wr(scc,R3,Rx8); /* RX 8 bits/char, disabled */
  647. wr(scc,R5,Tx8|DTR|RTS); /* TX 8 bits/char, disabled, DTR RTS */
  648. wr(scc,R9,VIS); /* vector includes status */
  649. wr(scc,R10,NRZ|z); /* select NRZ */
  650. wr(scc,R15,BRKIE); /* enable BREAK ext/status int */
  652. or(scc,R3,RxENABLE); /* enable receiver */
  653. or(scc,R5,TxENAB); /* enable transmitter */
  655. WRREG(scc->ctrl,RES_EXT_INT); /* reset ext/status interrupts */
  656. WRREG(scc->ctrl,RES_EXT_INT); /* must be done twice */
  657. scc->status = RDREG(scc->ctrl); /* read initial status */
  659. or(scc,R1,INT_ALL_Rx|TxINT_ENAB|EXT_INT_ENAB); /* enable interrupts */
  660. or(scc,R9,MIE); /* master interrupt enable */
  662. restore(i_state);
  663. return 0;
  664. }
  666. /* initialize an SCC channel in SDLC mode */
  667. static void
  668. scc_sdlc(scc)
  669. register struct sccchan *scc;
  670. {
  671. int i_state;
  673. scc->int_transmit = scc_sdlctx; /* set interrupt handlers */
  674. scc->int_extstat = scc_sdlcex;
  675. scc->int_receive = scc_sdlcrx;
  676. scc->int_special = scc_sdlcsp;
  678. i_state = dirps();
  680. wr(scc,R4,X1CLK|SDLC); /* *1 clock, SDLC mode */
  681. wr(scc,R1,z); /* no W/REQ operation */
  682. wr(scc,R3,Rx8|RxCRC_ENAB); /* RX 8 bits/char, CRC, disabled */
  683. wr(scc,R5,Tx8|DTR|TxCRC_ENAB); /* TX 8 bits/char, disabled, DTR */
  684. wr(scc,R6,z); /* SDLC address zero (not used) */
  685. wr(scc,R7,FLAG); /* SDLC flag value */
  686. wr(scc,R9,VIS); /* vector includes status */
  687. wr(scc,R10,CRCPS|NRZI|ABUNDER); /* CRC preset 1, select NRZI, ABORT on underrun */
  689. if (scc->extclock){ /* when using external clocks */
  690. /* RXclk RTxC, TXclk TRxC. */
  691. wr(scc,R11,RCRTxCP|TCTRxCP);
  692. wr(scc,R14,z); /* No BRG options */
  693. WRSCC(scc->ctrl,R14,DISDPLL|scc->wreg[R14]); /* No DPLL operation */
  694. } else {
  695. if(scc->fulldup){ /* when external clock divider */
  696. if(Sccinfo.pclk){ /* when using PCLK as clock source */
  697. /* RXclk DPLL, TXclk RTxC, out=BRG.  external /32 TRxC->RTxC */
  698. wr(scc,R11,RCDPLL|TCRTxCP|TRxCOI|TRxCBR);
  699. } else {
  700. /* RXclk DPLL, TXclk TRxC. external TX clock to TRxC */
  701. wr(scc,R11,RCDPLL|TCTRxCP);
  702. }
  703. } else { /* only half-duplex operation */
  704. /* RXclk DPLL, TXclk BRG. BRG reprogrammed at every TX/RX switch */
  705. #ifdef notdef /* KA9Q - for PSK modem */
  706. wr(scc,R11,RCDPLL|TCBR);
  707. #else
  708. /* DPLL -> Rx clk, DPLL -> Tx CLK, TxCLK -> TRxC pin */
  709. wr(scc,R11,RCDPLL|TCDPLL|TRxCOI|TRxCDP);
  710. #endif
  711. }
  712. wr(scc,R14,Sccinfo.pclk? BRSRC:z); /* BRG source = PCLK/RTxC */
  713. WRSCC(scc->ctrl,R14,SSBR|scc->wreg[R14]); /* DPLL source = BRG */
  714. WRSCC(scc->ctrl,R14,SNRZI|scc->wreg[R14]); /* DPLL NRZI mode */
  715. }
  716. wr(scc,R15,BRKIE|CTSIE|DCDIE); /* enable ABORT, CTS & DCD interrupts */
  718. if(RDREG(scc->ctrl) & DCD){ /* DCD is now ON */
  719. if (!scc->extclock)
  720. WRSCC(scc->ctrl,R14,SEARCH|scc->wreg[R14]); /* DPLL: enter search mode */
  721. or(scc,R3,ENT_HM|RxENABLE); /* enable the receiver, hunt mode */
  722. }
  723. WRREG(scc->ctrl,RES_EXT_INT); /* reset ext/status interrupts */
  724. WRREG(scc->ctrl,RES_EXT_INT); /* must be done twice */
  725. scc->status = RDREG(scc->ctrl); /* read initial status */
  727. or(scc,R1,INT_ALL_Rx|TxINT_ENAB|EXT_INT_ENAB); /* enable interrupts */
  728. or(scc,R9,MIE); /* master interrupt enable */
  730. restore(i_state);
  731. }
  733. /* set SCC channel speed
  734.  * clkmode specifies the division rate (1,16,32) inside the SCC
  735.  * returns the selected brgrate for "real speed" calculation
  736.  */
  737. static unsigned int
  738. scc_speed(scc,clkmode,speed)
  739. register struct sccchan *scc;
  740. unsigned int clkmode;
  741. long speed; /* the desired baudrate */
  742. {
  743. unsigned int brgrate;
  744. long spdclkm;
  745. int i_state;
  747. /* calculate baudrate generator value */
  749.     if ((spdclkm = speed * clkmode) == 0)
  750. return 65000U; /* avoid divide-by-zero */
  752. brgrate = (unsigned) ((Sccinfo.clk + spdclkm) / (spdclkm * 2)) - 2;
  754. i_state = dirps(); /* 2-step register accesses... */
  756. cl(scc,R14,BRENABL); /* disable baudrate generator */
  757. wr(scc,R12,brgrate); /* brg rate LOW */
  758. wr(scc,R13,brgrate >> 8); /* brg rate HIGH */
  759. or(scc,R14,BRENABL); /* enable baudrate generator */
  761. restore(i_state);
  762. return brgrate;
  763. }
  765. /* de-activate SCC channel */
  766. static int
  767. scc_stop(ifp)
  768. struct iface *ifp;
  769. {
  770. struct sccchan *scc = Sccchan[ifp->dev];
  771. int i_state;
  773. i_state = dirps();
  775. VOID(RDREG(scc->ctrl)); /* make sure pointer is written */
  776. wr(scc,R9,(ifp->dev % 2)? CHRB : CHRA); /* reset the channel */
  778. switch(ifp->iftype->type){
  779. case CL_SERIAL_LINE:
  780. case CL_KISS:
  781. free(scc->fifo.buf);
  782. default:
  783. break;
  784. }
  785. free(scc);
  786. Sccchan[ifp->dev] = NULL;
  787. restore(i_state);
  788. return 0;
  789. }
  791. /* de-activate SCC driver on program exit */
  792. void
  793. sccstop()
  794. {
  795. if(Sccinfo.init){ /* was it initialized? */
  796. maskoff(Sccinfo.ivec); /* disable the interrupt */
  797. setirq(Sccinfo.ivec,Orgivec); /* restore original interrupt vector */
  798. }
  799. }
  801. /* perform ioctl on SCC (async) channel
  802.  * this is used for SLIP mode only, and will read/set the line speed
  803.  */
  804. static int32
  805. scc_aioctl(ifp,cmd,set,val)
  806. struct iface *ifp;
  807. int cmd;
  808. int set;
  809. int32 val;
  810. {
  811. struct sccchan *scc;
  812. unsigned int brgrate;
  814. scc = Sccchan[ifp->dev];
  816. switch(cmd){
  817. case PARAM_SPEED:
  818. if(set){
  819. brgrate = scc_speed(scc,16,val);
  820. scc->speed = Sccinfo.clk / (32L * (brgrate + 2));
  821. }
  822. return scc->speed;
  823. }
  824. return 0;
  825. }
  827. /* perform ioctl on SCC (sdlc) channel
  828.  * this is used for AX.25 mode only, and will set the "kiss" parameters
  829.  */
  830. static int32
  831. scc_sioctl(ifp,cmd,set,val)
  832. struct iface *ifp;
  833. int cmd;
  834. int set;
  835. int32 val;
  836. {
  837. struct sccchan *scc;
  838. unsigned int brgrate;
  839. int i_state;
  841. scc = Sccchan[ifp->dev];
  843. switch(cmd){
  844. case PARAM_SPEED:
  845. if(set){
  846. if(val == 0)
  847. scc->extclock = 1;
  848. else {
  849.     brgrate = scc_speed(scc,32,val);/* init SCC speed */
  850.     scc->speed = Sccinfo.clk / (64L * (brgrate + 2));/* calc real speed */
  851. }
  852. }
  853. return scc->speed;
  854. case PARAM_TXDELAY:
  855. if(set)
  856. scc->a.txdelay = val;
  857. return scc->a.txdelay;
  858. case PARAM_PERSIST:
  859. if(set)
  860. scc->a.persist = val;
  861. return scc->a.persist;
  862. case PARAM_SLOTTIME:
  863. if(set)
  864. scc->a.slottime = val;
  865. return scc->a.slottime;
  866. case PARAM_TXTAIL:
  867. if(set)
  868. scc->a.tailtime = val;
  869. return scc->a.tailtime;
  870. case PARAM_FULLDUP:
  871. if(set)
  872. scc->a.fulldup = val;
  873. return scc->a.fulldup;
  874. case PARAM_WAIT:
  875. if(set)
  876. scc->a.waittime = val;
  877. return scc->a.waittime;
  878. case PARAM_MAXKEY:
  879. if(set)
  880. scc->a.maxkeyup = val;
  881. return scc->a.maxkeyup;
  882. case PARAM_MIN:
  883. if(set)
  884. scc->a.mintime = val;
  885. return scc->a.mintime;
  886. case PARAM_IDLE:
  887. if(set)
  888. scc->a.idletime = val;
  889. return scc->a.idletime;
  890. case PARAM_DTR:
  891. if(set){
  892. if(val)
  893. scc->wreg[R5] |= DTR;
  894. else
  895. scc->wreg[R5] &= ~DTR;
  897. i_state = dirps();
  898. if(scc->a.tstate == IDLE && scc->timercount == 0)
  899. scc->timercount = 1; /* force an update */
  900. restore(i_state);
  901. }
  902. return (scc->wreg[R5] & DTR) ? 1 : 0;
  903. case PARAM_GROUP:
  904. if(set)
  905. scc->group = val;
  906. return scc->group;
  907. }
  908. return -1;
  909. }
  911. /* start SCC transmitter when it is idle (SLIP/KISS mode only) */
  912. static void
  913. scc_sstart(scc)
  914. register struct sccchan *scc;
  915. {
  916. if(scc->tbp != NULL || /* busy */
  917.  scc->sndq == NULL) /* no work */
  918. return;
  920. scc->tbp = dequeue(&scc->sndq);
  921. WRREG(scc->data,FR_END);
  922. }
  924. /* show SCC status */
  925. int
  926. dosccstat()
  927. {
  928. register struct sccchan *scc;
  929. int i;
  931. if(!Sccinfo.init){
  932. printf("SCC driver not initializedn");
  933. return 0;
  934. }
  935. printf("Ch Iface    Sent   Rcvd   Error Space Overr   Rxints   Txints   Exints   Spintsn");
  937. for(i = 0; i <= Sccinfo.maxchan; i++){
  938. if((scc = Sccchan[i]) == NULL)
  939. continue;
  941. if(scc->int_receive == scc_asyrx)
  942. printf("%2d %-6s  ** asynch ** %7lu %5u %5u %8lu %8lu %8lu %8lun",i,scc->iface->name,
  943.     scc->rxerrs,scc->nospace,scc->rovers,
  944.     scc->rxints,scc->txints,scc->exints,scc->spints);
  945. else
  946. printf("%2d %-6s %6lu %6lu %7lu %5u %5u %8lu %8lu %8lu %8lun",i,scc->iface->name,
  947.     scc->enqueued,scc->rxframes,scc->rxerrs,scc->nospace,scc->rovers,
  948.     scc->rxints,scc->txints,scc->exints,scc->spints);
  949. }
  950. return 0;
  951. }
  953. /* send raw frame to SCC. used for AX.25 */
  954. static int
  955. scc_raw(
  956. struct iface *ifp,
  957. struct mbuf **bpp
  958. ){
  959. struct sccchan *scc;
  960. int i_state;
  962. dump(ifp,IF_TRACE_OUT,*bpp);
  963. ifp->rawsndcnt++;
  964. ifp->lastsent = secclock();
  966. scc = Sccchan[ifp->dev];
  968. if (scc->tx_inhibit){ /* transmitter inhibit */
  969. free_p(bpp);
  970. return -1;
  971.     }
  973. enqueue(&scc->sndq,bpp); /* enqueue packet */
  974. scc->enqueued++;
  976. i_state = dirps();
  978. if(scc->a.tstate == IDLE){ /* when transmitter is idle */
  979. scc->a.tstate = DEFER; /* start the key-up sequence */
  980. scc->a.maxdefer = TPS * scc->a.idletime /
  981. scc->a.slottime;
  982. scc->timercount = scc->a.waittime;
  983. }
  984. restore(i_state);
  985. return 0;
  986. }
  988. static int
  989. scc_send(
  990. int dev,
  991. struct mbuf **bpp
  992. ){
  993. struct sccchan *scc;
  995. scc = Sccchan[dev];
  996. enqueue(&scc->sndq,bpp);
  998. if(scc->tbp == NULL)
  999. scc_sstart(scc);
  1000. return(0);
  1001. }
  1003. /* initialize interface for AX.25 use */
  1004. static int
  1005. scc_call(ifp,call)
  1006. register struct iface *ifp;
  1007. char *call;
  1008. {
  1009. uint8 out[AXALEN];
  1011. ifp->hwaddr = mallocw(AXALEN);
  1012. if(setcall(out,call) == 0)
  1013. memcpy(ifp->hwaddr,out,AXALEN);
  1014. else
  1015. memcpy(ifp->hwaddr,Mycall,AXALEN);
  1016. return 0;
  1017. }
  1019. /* Interrupt handlers for asynchronous modes (kiss, slip) */
  1021. /* Transmitter interrupt handler */
  1022. /* This routine sends data from mbufs in SLIP format */
  1023. static void
  1024. scc_asytx(scc)
  1025. register struct sccchan *scc;
  1026. {
  1027. register struct mbuf *bp;
  1029. scc->txints++;
  1031. if(scc->txchar != 0){ /* a character pending for transmit? */
  1032. WRREG(scc->data,scc->txchar); /* send it now */
  1033. scc->txchar = 0; /* next time, ignore it */
  1034. return;
  1035. }
  1037. if(scc->tbp == NULL){ /* nothing to send? */
  1038. if((scc->tbp = scc->sndq) != NULL){ /* dequeue next frame */
  1039. scc->sndq = scc->sndq->anext;
  1040. WRREG(scc->data,FR_END); /* send FR_END to flush line garbage */
  1041. } else {
  1042. WRREG(scc->ctrl,RES_Tx_P); /* else only reset pending int */
  1043. }
  1044. return;
  1045. }
  1046. while ((bp = scc->tbp)->cnt == 0){ /* nothing left in this mbuf? */
  1047. bp = bp->next; /* save link to next */
  1049. free_mbuf(&scc->tbp);
  1051. if((scc->tbp = bp) == NULL){ /* see if more mbufs follow */
  1052. WRREG(scc->data,FR_END); /* frame complete, send FR_END */
  1053. return;
  1054. }
  1055. }
  1056. /* now bp = scc->tbp (either from while or from if stmt above) */
  1058. WRREG(scc->data,*(bp->data)); /* just send the character */
  1059. bp->cnt--; /* decrease mbuf byte count */
  1060. bp->data++; /* and increment the data pointer */
  1061. }
  1063. /* External/Status interrupt handler */
  1064. static void
  1065. scc_asyex(scc)
  1066. register struct sccchan *scc;
  1067. {
  1068. register unsigned char status,changes;
  1070. scc->exints++;
  1071. status = RDREG(scc->ctrl);
  1072. changes = status ^ scc->status;
  1074. if(changes & BRK_ABRT){ /* BREAK? */
  1075. if((status & BRK_ABRT) == 0) /* BREAK now over? */
  1076. VOID(RDREG(scc->data)); /* read the NUL character */
  1077. }
  1078. scc->status = status;
  1079. WRREG(scc->ctrl,RES_EXT_INT);
  1080. }
  1082. /* Receiver interrupt handler under NOS.
  1083.  * Since the higher serial protocol routines are all written to work
  1084.  * well with the routines in 8250.c, it makes sense to handle
  1085.  * asynch i/o with the 8530 in a similar manner. Therefore, these
  1086.  * routines are as close to their counterparts in 8250.c as possible.
  1087.  */
  1088.  
  1089. static void
  1090. scc_asyrx(scc)
  1091. register struct sccchan *scc;
  1092. {
  1093. register struct fifo *fp;
  1094. char c;
  1096. scc->rxints++;
  1098. fp = &(scc->fifo);
  1099. do {
  1100. c = RDREG(scc->data);
  1101. if(fp->cnt != fp->bufsize){
  1102. *fp->wp++ = c;
  1103. if(fp->wp >= &fp->buf[fp->bufsize])
  1104. fp->wp = fp->buf;
  1105. fp->cnt++;
  1106. } else
  1107. scc->nospace++;
  1108. } while(RDREG(scc->ctrl) & Rx_CH_AV);
  1109. ksignal(fp,1); /* eventually move this to timer routine */
  1110. }
  1112. /* Blocking read from asynch input.
  1113.  * Essentially the same as get_asy() in 8250.c
  1114.  * See comments in asyrxint().
  1115.  */
  1116. static int
  1117. get_scc(dev)
  1118. int dev;
  1119. {
  1120. register struct fifo *fp;
  1121. uint8 c;
  1122. int tmp;
  1123. int i_state;
  1125. fp = &(Sccchan[dev]->fifo);
  1127. for(;;){
  1128. i_state = dirps();
  1129. tmp = fp->cnt;
  1130. if(tmp != 0){
  1131. fp->cnt--;
  1132. restore(i_state);
  1133. break;
  1134. }
  1135. restore(i_state);
  1136. kwait(fp);
  1137. }
  1138. c = *fp->rp++;
  1139. if(fp->rp >= &fp->buf[fp->bufsize])
  1140. fp->rp = fp->buf;
  1142. return c;
  1143. }
  1145. int
  1146. scc_frameup(dev)
  1147. int dev;
  1148. {
  1149. Sccchan[dev]->rxframes++;
  1150. return 0;
  1151. }
  1153. /* Receive Special Condition interrupt handler */
  1154. static void
  1155. scc_asysp(scc)
  1156. register struct sccchan *scc;
  1157. {
  1158. register unsigned char status;
  1160. scc->spints++;
  1162. status = rd(scc,R1); /* read receiver status */
  1163. VOID(RDREG(scc->data)); /* flush offending character */
  1165. if(status & (CRC_ERR | Rx_OVR)) /* did a framing error or overrun occur ? */
  1166. scc->rovers++; /* report as overrun */
  1168. WRREG(scc->ctrl,ERR_RES);
  1169. }
  1171. /* Interrupt handlers for sdlc mode (AX.25) */
  1173. /* Transmitter interrupt handler */
  1174. static void
  1175. scc_sdlctx(scc)
  1176. register struct sccchan *scc;
  1177. {
  1178. register struct mbuf *bp;
  1180. scc->txints++;
  1182. switch(scc->a.tstate){ /* look at transmitter state */
  1183. case ACTIVE: /* busy sending data bytes */
  1184. while ((bp = scc->tbp)->cnt == 0){ /* nothing left in this mbuf? */
  1185. bp = bp->next; /* save link to next */
  1186. free_mbuf(&scc->tbp); /*KM*/
  1187. if((scc->tbp = bp) == NULL){/* see if more mbufs follow */
  1188. if(RDREG(scc->ctrl) & TxEOM){ /* check tx underrun status */
  1189. scc->rovers++; /* oops, an underrun! count them */
  1190. WRREG(scc->ctrl,SEND_ABORT);/* send an abort to be sure */
  1191. scc->a.tstate = TAIL; /* key down tx after TAILTIME */
  1192. scc->timercount = scc->a.tailtime;
  1193. return;
  1194. }
  1195. cl(scc,R10,ABUNDER); /* frame complete, allow CRC transmit */
  1196. scc->a.tstate = FLUSH;
  1197. WRREG(scc->ctrl,RES_Tx_P); /* reset pending int */
  1198. return;
  1199. }
  1200. }
  1201. /* now bp = scc->tbp (either from while or from if stmt above) */
  1202. WRREG(scc->data,*(bp->data++)); /* send the character */
  1203. bp->cnt--; /* decrease mbuf byte count */
  1204. return;
  1205. case FLUSH: /* CRC just went out, more to send? */
  1206. or(scc,R10,ABUNDER); /* re-install underrun protection */
  1207. /* verify that we are not exeeding max tx time (if defined) */
  1208. if((scc->timercount != 0 || scc->a.maxkeyup == 0) &&
  1209.  (scc->tbp = scc->sndq) != NULL){ /* dequeue a frame */
  1210. scc->sndq = scc->sndq->anext;
  1211. WRREG(scc->ctrl,RES_Tx_CRC); /* reset the TX CRC generator */
  1212. scc->a.tstate = ACTIVE;
  1213. scc_sdlctx(scc); /* write 1st byte */
  1214. WRREG(scc->ctrl,RES_EOM_L); /* reset the EOM latch */
  1215. return;
  1216. }
  1217. scc->a.tstate = TAIL; /* no more, key down tx after TAILTIME */
  1218. scc->timercount = scc->a.tailtime;
  1219. WRREG(scc->ctrl,RES_Tx_P);
  1220. return;
  1221. default: /* another state */
  1222. WRREG(scc->ctrl,RES_Tx_P); /* then don't send anything */
  1223. return;
  1224. }
  1225. }
  1227. /* External/Status interrupt handler */
  1228. static void
  1229. scc_sdlcex(scc)
  1230. register struct sccchan *scc;
  1231. {
  1232. register unsigned char status,changes;
  1234. scc->exints++;
  1235. status = RDREG(scc->ctrl);
  1236. changes = status ^ scc->status;
  1238. if(changes & BRK_ABRT){ /* Received an ABORT */
  1239. if(status & BRK_ABRT){ /* is this the beginning? */
  1240. if(scc->rbp != NULL){/* did we receive something? */
  1241. /* check if a significant amount of data came in */
  1242. /* this is because the drop of DCD tends to generate an ABORT */
  1243. if(scc->rbp->next != NULL || scc->rbp->cnt > 0)
  1244. scc->rxerrs++; /* then count it as an error */
  1245. scc_tossb(scc); /* throw away buffer */
  1246. }
  1247. VOID(RDREG(scc->data)); /* flush the FIFO */
  1248. VOID(RDREG(scc->data));
  1249. VOID(RDREG(scc->data));
  1250. }
  1251. }
  1252. if(changes & CTS){ /* CTS input changed state */
  1253. if(status & CTS){ /* CTS is now ON */
  1254. if(scc->a.tstate == KEYWT &&
  1255. scc->a.txdelay == 0) /* zero TXDELAY = wait for CTS */
  1256. scc->timercount = 1; /* it will start within 10 ms */
  1257. }
  1258. }
  1259. if(changes & DCD){ /* DCD input changed state */
  1260. if(status & DCD){ /* DCD is now ON */
  1261. if (!scc->extclock)
  1262. WRSCC(scc->ctrl,R14,SEARCH|scc->wreg[R14]); /* DPLL: enter search mode */
  1263. or(scc,R3,ENT_HM|RxENABLE); /* enable the receiver, hunt mode */
  1264. } else { /* DCD is now OFF */
  1265. cl(scc,R3,ENT_HM|RxENABLE); /* disable the receiver */
  1266. VOID(RDREG(scc->data)); /* flush the FIFO */
  1267. VOID(RDREG(scc->data));
  1268. VOID(RDREG(scc->data));
  1269. if(scc->rbp != NULL){/* did we receive something? */
  1270. /* check if a significant amount of data came in */
  1271. /* this is because some characters precede the drop of DCD */
  1272. if(scc->rbp->next != NULL || scc->rbp->cnt > 0)
  1273. scc->rxerrs++; /* then count it as an error */
  1274. scc_tossb(scc); /* throw away buffer */
  1275. }
  1276. }
  1277. }
  1278. scc->status = status;
  1279. WRREG(scc->ctrl,RES_EXT_INT);
  1280. }
  1282. /* Receiver interrupt handler */
  1283. static void
  1284. scc_sdlcrx(scc)
  1285. register struct sccchan *scc;
  1286. {
  1287. register struct mbuf *bp;
  1289. scc->rxints++;
  1291. if((bp = scc->rbp1) == NULL){ /* no buffer available now */
  1292. if(scc->rbp == NULL){
  1293. if((bp = alloc_mbuf(scc->bufsiz+sizeof(struct iface *))) != NULL){
  1294. scc->rbp = scc->rbp1 = bp;
  1295. bp->cnt = 0;
  1296. }
  1297. } else if((bp = alloc_mbuf(scc->bufsiz)) != NULL){
  1298. scc->rbp1 = bp;
  1299. for(bp = scc->rbp; bp->next != NULL; bp = bp->next)
  1300. ;
  1301. bp->next = scc->rbp1;
  1302. bp = scc->rbp1;
  1303. }
  1304. if(bp == NULL){
  1305. VOID(RDREG(scc->data)); /* so we have to discard the char */
  1306. or(scc,R3,ENT_HM); /* enter hunt mode for next flag */
  1307. scc_tossb(scc); /* put buffers back on pool */
  1308. scc->nospace++; /* count these events */
  1309. return;
  1310. }
  1311. }
  1313. /* now, we have a buffer (at bp). read character and store it */
  1314. bp->data[bp->cnt++] = RDREG(scc->data);
  1316. if(bp->cnt == bp->size) /* buffer full? */
  1317. scc->rbp1 = NULL; /* acquire a new one next time */
  1318. }
  1320. /* Receive Special Condition interrupt handler */
  1321. static void
  1322. scc_sdlcsp(scc)
  1323. register struct sccchan *scc;
  1324. {
  1325. register unsigned char status;
  1326. register struct mbuf *bp;
  1328. scc->spints++;
  1330. status = rd(scc,R1); /* read receiver status */
  1331. VOID(RDREG(scc->data)); /* flush offending character */
  1333. if(status & Rx_OVR){ /* receiver overrun */
  1334. scc->rovers++; /* count them */
  1335. or(scc,R3,ENT_HM); /* enter hunt mode for next flag */
  1336. scc_tossb(scc); /* rewind the buffer and toss */
  1337. }
  1338. if(status & END_FR && /* end of frame */
  1339. scc->rbp != NULL){ /* at least received something */
  1340. if((status & CRC_ERR) == 0 && /* no CRC error is indicated */
  1341. (status & 0xe) == RES8 && /* 8 bits in last byte */
  1342. scc->rbp->cnt > 0){
  1344. /* we seem to have a good frame. but the last byte received */
  1345. /* from rx interrupt is in fact a CRC byte, so discard it */
  1346. if(scc->rbp1 != NULL){
  1347. scc->rbp1->cnt--; /* current mbuf was not full */
  1348. } else {
  1349. for(bp = scc->rbp; bp->next != NULL; bp = bp->next);
  1350. /* find last mbuf */
  1352. bp->cnt--; /* last byte is first CRC byte */
  1353. }
  1355. net_route(scc->iface,&scc->rbp);
  1357. scc->rbp = scc->rbp1 = NULL;
  1358. scc->rxframes++;
  1359. } else { /* a bad frame */
  1360. scc_tossb(scc); /* throw away frame */
  1361. scc->rxerrs++;
  1362. }
  1363. }
  1364. WRREG(scc->ctrl,ERR_RES);
  1365. }
  1367. /* Throw away receive mbuf(s) when an error occurred */
  1368. static void
  1369. scc_tossb (scc)
  1370. register struct sccchan *scc;
  1371. {
  1372. register struct mbuf *bp;
  1374. if((bp = scc->rbp) != NULL){
  1375. free_p(&bp->next);
  1376. free_p(&bp->dup); /* Should be NULL */
  1377. bp->next = NULL;
  1378. scc->rbp1 = bp; /* Don't throw this one away */
  1379. bp->cnt = 0; /* Simply rewind it */
  1380. }
  1381. }
  1383. /* Switch the SCC to "transmit" mode */
  1384. /* Only to be called from an interrupt handler, while in AX.25 mode */
  1385. static void
  1386. scc_txon(scc)
  1387. register struct sccchan *scc;
  1388. {
  1389.     if (!scc->fulldup && !scc->extclock){ /* no fulldup divider? */
  1390. cl(scc,R3,RxENABLE); /* then switch off receiver */
  1391. cl(scc,R5,TxENAB); /* transmitter off during switch */
  1392. scc_speed(scc,1,scc->speed); /* reprogram baudrate generator */
  1393. }
  1394. or(scc,R5,RTS|TxENAB); /* set the RTS line and enable TX */
  1395. if(Sccinfo.hwtype & HWPRIMUS) /* PRIMUS has another PTT bit... */
  1396. WRREG(scc->ctrl + 4,Sccinfo.hwparam | 0x80); /* set that bit! */
  1397. }
  1399. /* Switch the SCC to "receive" mode (or: switch off transmitter)
  1400.  * Only to be called from an interrupt handler, while in AX.25 mode
  1401.  */
  1402. static void
  1403. scc_txoff(scc)
  1404. register struct sccchan *scc;
  1405. {
  1406. cl(scc,R5,RTS); /* turn off RTS line */
  1407. if(Sccinfo.hwtype & HWPRIMUS) /* PRIMUS has another PTT bit... */
  1408. WRREG(scc->ctrl + 4,Sccinfo.hwparam); /* clear that bit! */
  1410.     if (!scc->fulldup && !scc->extclock){ /* no fulldup divider? */
  1411. cl(scc,R5,TxENAB); /* then disable the transmitter */
  1412. scc_speed(scc,32,scc->speed); /* back to receiver baudrate */
  1413. }
  1414. }
  1416. /* SCC timer interrupt handler. Will be called every 1/TPS s by the 
  1417.  * routine systick in pc.c
  1418.  */
  1419. void scctimer()
  1420. {
  1421. register struct sccchan *scc;
  1422. register struct sccchan **sccp;
  1423. int i_state;
  1425. i_state = dirps();
  1426. for(sccp = Sccchan + Sccinfo.maxchan; sccp >= Sccchan; sccp--){
  1427. if((scc = *sccp) != NULL &&
  1428.   scc->timercount != 0 &&
  1429.   --(scc->timercount) == 0){
  1430. /* handle an SCC timer event for this SCC channel
  1431.  * this can only happen when the channel is AX.25 type
  1432.  * (the SLIP/KISS driver does not use timers)
  1433.  */
  1434. switch(scc->a.tstate){
  1435. case IDLE: /* it was idle, this is FULLDUP2 timeout */
  1436. scc_txoff(scc); /* switch-off the transmitter */
  1437. break;
  1438. case DEFER: /* trying to get the channel */
  1439. /* operation is as follows:
  1440.  * CSMA: when channel clear AND persistence randomgenerator
  1441.  *  wins, AND group restrictions allow it:
  1442.  * keyup the transmitter
  1443.  *  if not, delay one SLOTTIME and try again
  1444.  * FULL: always keyup the transmitter
  1445.  */
  1446. if(scc->a.fulldup == 0){
  1447. Random = 21 * Random + 53;
  1448. if(scc->status & DCD || scc->a.persist < Random){
  1449. /* defer transmission again. check for limit */
  1450. defer_it: if(--(scc->a.maxdefer) == 0){
  1451. /* deferred too long. choice is to:
  1452.  * - throw away pending frames, or
  1453.  * - smash-on the transmitter and send them.
  1454.  * the first would be the choice in a clean
  1455.  * environment, but in the amateur radio world
  1456.  * a distant faulty station could tie us up
  1457.  * forever, so the second may be better...
  1458. */
  1459. #ifdef THROW_AWAY_AFTER_DEFER_TIMEOUT
  1460. struct mbuf *bp,*bp1;
  1462. while ((bp = scc->sndq) != NULL){
  1463. scc->sndq = scc->sndq->anext;
  1464. free_p(&bp);
  1465. }
  1466. #else
  1467. goto keyup; /* just keyup the transmitter... */
  1468. #endif
  1469. }
  1470. scc->timercount = scc->a.slottime;
  1471. break;
  1472. }
  1473. if(scc->group != NOGROUP){
  1474. int i;
  1475. struct sccchan *scc2;
  1477. for(i = 0; i <= Sccinfo.maxchan; i++)
  1478. if((scc2 = Sccchan[i]) != NULL &&
  1479.  scc2 != scc &&
  1480.  scc2->group & scc->group &&
  1481.  ((scc->group & TXGROUP && scc2->wreg[R5] & RTS) ||
  1482.  (scc->group & RXGROUP && scc2->status & DCD))){
  1483. goto defer_it;
  1484. }
  1485. }
  1486. }
  1487. case KEYUP: /* keyup transmitter (note fallthrough) */
  1488. keyup: if((scc->wreg[R5] & RTS) == 0){ /* when not yet keyed */
  1489. scc->a.tstate = KEYWT;
  1490. scc->timercount = scc->a.txdelay; /* 0 if CTSwait */
  1491. scc_txon(scc);
  1492. break;
  1493. }
  1494. /* when already keyed, directly fall through */
  1495. case KEYWT: /* waited for CTS or TXDELAY */
  1496. /* when a frame is available (it should be...):
  1497.  * - dequeue it from the send queue
  1498.  * - reset the transmitter CRC generator
  1499.  * - set a timeout on transmission length, if defined
  1500.  * - send the first byte of the frame
  1501.  * - reset the EOM latch
  1502.  * when no frame available, proceed to TAIL handling
  1503.  */
  1504. if((scc->tbp = scc->sndq) != NULL){
  1505. scc->sndq = scc->sndq->anext;
  1506. WRREG(scc->ctrl,RES_Tx_CRC);
  1507. scc->a.tstate = ACTIVE;
  1508. scc->timercount = TPS * scc->a.maxkeyup;
  1509. scc_sdlctx(scc);
  1510. WRREG(scc->ctrl,RES_EOM_L);
  1511. break;
  1512. }
  1513. /* when no frame queued, fall through to TAIL case */
  1514. case TAIL: /* at end of frame */
  1515. /* when fulldup is 0 or 1, switch off the transmitter.
  1516.  * when frames are still queued (because of transmit time limit),
  1517.  * restart the procedure to get the channel after MINTIME.
  1518.  * when fulldup is 2, the transmitter remains keyed and we
  1519.  * continue sending. IDLETIME is an idle timeout in this case.
  1520.  */
  1521. if(scc->a.fulldup < 2){
  1522. scc->a.tstate = IDLE;
  1523. scc_txoff(scc);
  1525. if(scc->sndq != NULL){
  1526. scc->a.tstate = DEFER;
  1527. scc->a.maxdefer = TPS * scc->a.idletime /
  1528.  scc->a.slottime;
  1529. scc->timercount = TPS * scc->a.mintime;
  1530. }
  1531. break;
  1532. }
  1533. if(scc->sndq != NULL){ /* still frames on the queue? */
  1534. scc->a.tstate = KEYWT; /* continue sending */
  1535. scc->timercount = TPS * scc->a.mintime; /* after mintime */
  1536. } else {
  1537. scc->a.tstate = IDLE;
  1538. scc->timercount = TPS * scc->a.idletime;
  1539. }
  1540. break;
  1541. case ACTIVE: /* max keyup time expired */
  1542. case FLUSH: /* same while in flush mode */
  1543. break; /* no action required yet */
  1544. default: /* unexpected state */
  1545. scc->a.tstate = IDLE; /* that should not happen, but... */
  1546. scc_txoff(scc); /* at least stop the transmitter */
  1547. break;
  1548. }
  1549. }
  1550. }
  1551. restore(i_state);
  1552. }