DeltaLima
/
TheNetNode-CB
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
TheNetNode-CB/os/go32/scc.c

892 lines
24 KiB
C
Executable File
Raw Permalink Blame History

/************************************************************************/
/* */
/* ***** ***** */
/* ***** ***** */
/* ***** ***** */
/* ***** ***** */
/* *************** *************** */
/* ***************** ***************** */
/* *************** *************** */
/* ***** ***** TheNetNode */
/* ***** ***** Portable */
/* ***** ***** Network */
/* ***** ***** Software */
/* */
/* File os/go32/scc.c (maintained by: ???) */
/* */
/* This file is part of "TheNetNode" - Software Package */
/* */
/* Copyright (C) 1998 - 2008 NORD><LINK e.V. Braunschweig */
/* */
/* This program is free software; you can redistribute it and/or modify */
/* it under the terms of the NORD><LINK ALAS (Allgemeine Lizenz fuer */
/* Amateurfunk Software) as published by Hans Georg Giese (DF2AU) */
/* on 13/Oct/1992; either version 1, or (at your option) any later */
/* version. */
/* */
/* This program is distributed WITHOUT ANY WARRANTY only for further */
/* development and learning purposes. See the ALAS (Allgemeine Lizenz */
/* fuer Amateurfunk Software). */
/* */
/* You should have received a copy of the NORD><LINK ALAS (Allgemeine */
/* Lizenz fuer Amateurfunk Software) along with this program; if not, */
/* write to NORD><LINK e.V., Hinter dem Berge 5, D-38108 Braunschweig */
/* */
/* Dieses Programm ist PUBLIC DOMAIN, mit den Einschraenkungen durch */
/* die ALAS (Allgemeine Lizenz fuer Amateurfunk Software), entweder */
/* Version 1, veroeffentlicht von Hans Georg Giese (DF2AU), */
/* am 13.Oct.1992, oder (wenn gewuenscht) jede spaetere Version. */
/* */
/* Dieses Programm wird unter Haftungsausschluss vertrieben, aus- */
/* schliesslich fuer Weiterentwicklungs- und Lehrzwecke. Naeheres */
/* koennen Sie der ALAS (Allgemeine Lizenz fuer Amateurfunk Software) */
/* entnehmen. */
/* */
/* Sollte dieser Software keine ALAS (Allgemeine Lizenz fuer Amateur- */
/* funk Software) beigelegen haben, wenden Sie sich bitte an */
/* NORD><LINK e.V., Hinter dem Berge 5, D-38108 Braunschweig */
/* */
/************************************************************************/
#if defined(__GO32__)
#define SCC_RXSIZE 8192 /* bei DPMI kann es mehr sein */
#else
#define SCC_RXSIZE 1024 /* Groesse eines Buffers */
#endif
#define SCC_TXSIZE 512
#define SCCCHANS 8
#define PCLK 4915200L
/*** Z8530 ******************************************************************/
/* Write Registers */
#define RES_EX_INT 0x10 /* WR0 */
#define RES_TX_IP 0x28
#define RES_ERR 0x30
#define RES_TX_CRC 0x80
#define RES_EOM 0xC0
#define EX_IE 0x01 /* WR1 */
#define TX_IE 0x02
#define RX_IE 0x10
#define RX_DIS 0xC8 /* WR3 */
#define RX_EN 0xC9
#define SDLC 0x20 /* WR4 */
#define TX_DIS 0x61 /* WR5 */
#define TX_EN 0x69
#define RTS 0x02
#define SDLC_FLAG 0x7E /* WR7 */
#define MINT_EN 0x0A /* WR9 */
#define HW_RES 0xC0
#define NRZ 0x80 /* WR10 */
#define NRZI 0xA0
#define ABUNDER 0x04
#define TRxC_RTxC 0x20 /* WR11 */
#define DPLL_RTxC 0x64
#define DPLL_BRG 0x74
#define TRxOUT_BRG 0x02
#define TRxOUT_DPLL 0x03
#define DPLL_EN 0x23 /* WR14 */
#define DPLL_DIS 0x60
#define DPLL_SRCBRG 0x80
#define DPLL_NRZI 0xE0
#define BRG_EN 0x63
#define ZC_IE 0x02 /* WR15 */
#define DCD_IE 0x08
#define SYNC_IE 0x10
#define CTS_IE 0x20
/* Read Registers */
#define DCD 0x08 /* RR0 */
#define HUNT 0x10
#define CTS 0x20
#define TX_EOM 0x40
#define ABORT 0x80
#define RESIDUE 0x0E /* RR1 */
#define RES8 0x06
#define RX_OVR 0x20
#define CRC_ERR 0x40
#define SDLC_EOF 0x80
#define MIN_LEN 15
/*** Macros *****************************************************************/
#define LOBYTE(val) ((val) & 0xFF)
#define HIBYTE(val) ((val) >> 8)
#define set(var, bit) var |= (1 << bit)
#define res(var, bit) var &= ~(1 << bit)
#define SCCDELAY inp (0xE4) /* non-existing port (2us) */
#ifndef outp
#define outp(p,b) outportb(p,b)
#endif
#ifndef inp
#define inp(p) inportb(p)
#endif
#define WR0(val) outp ((SCCDELAY, scc->ctrl), val)
#define WR8(val) WR (8, val)
#define WR(reg, val) outp ((SCCDELAY, outp (scc->ctrl, reg), \
SCCDELAY, scc->ctrl), val)
#define RR0 inp ((SCCDELAY, scc->ctrl))
#define RR8 inp ((SCCDELAY, scc->data))
#define RR(reg) inp ((SCCDELAY, outp (scc->ctrl, reg), \
SCCDELAY, scc->ctrl))
#define not0(par) (par ? par : 1)
enum {TX_IDLE, TX_DWAIT, TX_DELAY, TX_ACTIVE, TX_FLUSH, TX_TAIL};
typedef struct __scc_struct
{
int l2port;
unsigned chan;
unsigned data, ctrl;
unsigned baud;
int flags;
int dcd;
int rx_err;
unsigned rx_len;
int tx_state;
unsigned tx_timer;
char *tx_buf;
char *tx_ptr;
int tx_len;
MBHEAD *rxfhd;
UBYTE rr0;
unsigned errors;
unsigned tailtime;
unsigned slottime;
unsigned persistance;
unsigned txdelay;
unsigned overruns;
unsigned underruns;
unsigned crcerrors;
unsigned lenerrors;
unsigned buferrors;
} __scc_struct;
typedef struct __scc_board {
char *name;
int chans;
unsigned base;
unsigned irq;
int data[SCCCHANS];
int ctrl;
} __scc_board;
static __scc_struct sccchans[SCCCHANS];
static int scc_major = 0;
static unsigned sccbase;
static unsigned sccirq;
static unsigned sccboard;
static int sccoldmask;
static unsigned sccminors;
static UWORD *sccbuf, *sccin, *sccout;
static __scc_board sccboardtab[] =
{
{"DSCC", 8, 0x300, 7, {1, 0, 3, 2, 5, 4, 7, 6}, 16}, /* DSCC */
{"OSCC", 4, 0x150, 3, {3, 1, 7, 5, 0, 0, 0, 0}, -1}, /* OSCC */
{"USCC", 4, 0x300, 7, {0, 1, 2, 3, 0, 0, 0, 0}, 4}, /* USCC */
{NULL , 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0}
};
static void scc_int(int);
static void int_tx(__scc_struct *);
static void int_rx(__scc_struct *);
static void int_ex(__scc_struct *);
static void int_sp(__scc_struct *);
static void scc_clk (__scc_struct *, int);
static int scc_init(void);
static void scc_exit(void);
static void scc_timer(UWORD);
/* Wenn der Sender keine Daten mehr ausstehen hat, wird ein weiteres
* Frame in den Sendebuffer kopiert. */
static void scc_put_frame(__scc_struct *scc)
{
MBHEAD *fbp;
int port;
LHEAD *l2flp;
if (scc->tx_len == 0) { /* erst senden wenn alles raus ist */
if ((port = scc->l2port) == -1) return;
if (kick[port]) {
/* ein weiteres Frame aus der Sendeliste holen */
l2flp = &txl2fl[port];
ulink((LEHEAD *)(fbp = (MBHEAD *) l2flp->head));
kick[port] = ((LHEAD *)l2flp->head != l2flp);
/* Frame aus dem Buffer in den SCC-Buffer kopieren. Hier wird
der Interrupt nicht gesperrt, da tx_len zuletzt und atomic
gesetzt wird. */
scc->tx_len = cpymbflat(scc->tx_ptr = scc->tx_buf, fbp);
relink((LEHEAD *)fbp, /* als gesendet betrachten und in */
(LEHEAD *)stfl.tail); /* die gesendet Liste umhaengen */
/* Wenn der sender noch nicht an ist, starten wir die Kanal-
Arbitrierung, ansonsten stoppen wir ein eventuelles TXTAIL
und gehen wieder zum senden ueber. */
disable();
switch (scc->tx_state) {
case TX_IDLE:
scc->tx_timer = scc->flags & MODE_d ? 1 : not0 (scc->slottime);
scc->tx_state = TX_DWAIT;
break;
case TX_TAIL:
scc->tx_timer = 1;
scc->tx_state = TX_DELAY;
}
enable();
}
}
}
/* Der SCC-Empfangs-Ringbuffer wird geleert. Dort werden von allen Kanaelen
* Empfangsdaten gesammelt. Das Format entspricht dem alten l1put().
*/
static void scc_get_frame(void)
{
int port, len;
MBHEAD **rxfbpp;
unsigned action;
__scc_struct *scc;
LOOP {
disable();
if (sccout == sccin) {
enable();
break;
}
action = *sccout++; /* Zeichen aus dem Ringbuffer lesen */
if (sccout >= sccbuf+SCC_RXSIZE)
sccout = sccbuf;
enable();
scc = sccchans + ((action>>8) & 0x7F);
if ((port = scc->l2port) == -1)
continue;
rxfbpp = &scc->rxfhd; /* Adresse RX-Framezeiger */
if (!(action & 0x8000)) /* Zeichen oder Befehl ? */
{ /* Zeichen : */
if (!*rxfbpp) /* RX-Frame aktiv ? */
{
*rxfbpp = (MBHEAD *)allocb(ALLOC_MBHEAD); /* nein - neues anlegen */
(*rxfbpp)->l2port = port; /* fuer port */
}
putchr(action & 0xFF,*rxfbpp); /* Zeichen in Frame */
}
else /* Befehl : */
if (*rxfbpp) /* nur wenn Frame aktiv */
{ /* Befehl ausfuehren */
if (action & 0x0001) /* Frame in Muelleimer */
relink((LEHEAD *)*rxfbpp, (LEHEAD *)trfl.tail);
else { /* Frame in RX-Liste */
len = (action>>1)&3;
if ((*rxfbpp)->mbpc > len) /* FCS eleminieren */
(*rxfbpp)->mbpc -= len; /* das erste Byte kommt */
/* noch vor HUNT */
relink((LEHEAD *)*rxfbpp, (LEHEAD *)rxfl.tail);
}
*rxfbpp = NULL; /* kein RX-Frame aktiv */
}
}
}
static void scc(void)
{
__scc_struct *scc;
if (scc_major == 0)
return;
scc_get_frame();
for (scc = sccchans; scc < sccchans+sccminors; scc++) {
scc_put_frame(scc);
}
}
static WORD scc_dcd(PORTINFO *port)
{
__scc_struct *scc;
int state = 0;
scc = &sccchans[port->minor];
if (scc->tx_state)
state |= PTTFLAG;
if (scc->dcd)
state |= DCDFLAG;
return(state);
}
static void scc_ctl(int req, int port)
{
__scc_struct *scc;
int minor;
PORTINFO *p;
p = portpar+port;
minor = p->minor;
scc = &sccchans[minor];
switch (req) {
case L1CCMD :
case L1CRES :
if (p->speed > 384)
p->speed = 384;
if (p->speed < 3)
p->speed = 3;
scc->baud = (unsigned) (p->speed * 100);
scc->slottime = p->slottime;
scc->persistance = p->persistance;
scc->txdelay = p->txdelay;
scc->tailtime = p->speed == 3 ? 4 : TAILTIME;
scc->flags = p->l1mode;
WR (4, SDLC);
WR (10, scc->flags & MODE_z ? NRZ | ABUNDER : NRZI | ABUNDER);
WR (7, SDLC_FLAG);
WR (3, RX_DIS);
WR (5, TX_DIS);
scc_clk (scc, scc->tx_state != TX_IDLE);
WR (3, RX_EN);
WR (5, scc->flags & MODE_t ? TX_EN : TX_DIS);
WR (15, SYNC_IE | DCD_IE);
WR0 (RES_EX_INT);
WR0 (RES_EX_INT);
WR (1, EX_IE | TX_IE | RX_IE);
scc->rr0 = RR0;
/* nochmal zur Sicherheit den CHIP-interrupt-master-enable an */
WR (2, (scc->chan>>1) << 4);
WR (9, MINT_EN);
break;
}
default_l1ctl(req, port); /* Flags loeschen */
};
static int scc_istome(int major, char *devname)
{
char name[21], *cp;
int minor = 0;
strncpy(name, devname, 20); /* Minor bestimmen und abschneiden */
name[20] = 0;
for (cp = name; isalpha(*cp); cp++); /* Zahl suchen */
if (isdigit(*cp)) minor = atoi(cp);
*cp = 0; /* kann nicht schaden */
if (minor < 0 || minor >= sccminors)
return(NO_MINOR); /* falscher Geraetekanal (minor) */
return(minor);
}
static int scc_attach(int port, int minor, BOOLEAN check_only)
{
__scc_struct *scc;
scc = &sccchans[minor];
if (scc_major) {
if (scc->l2port == -1) {
if (!check_only) {
scc->l2port = port;
portpar[port].minor = minor;
scc_ctl(L1CRES, port);
}
return(1);
}
if (scc->l2port == port)
return(1);
}
return(0); /* versuchte Doppeleintragung */
}
static int scc_detach(int port)
{
__scc_struct *scc = &sccchans[portpar[port].minor];
WR (1, 0);
if (scc->rxfhd) {
dealmb(scc->rxfhd);
scc->rxfhd = NULL;
}
scc->l2port = -1;
return(1);
}
static void scc_info(int what, int port, MBHEAD *mbp)
{
int minor, cnt;
__scc_struct *scc;
minor = portpar[port].minor;
switch (what) {
case HW_INF_IDENT :
case HW_INF_INFO :
putprintf(mbp, "%s%u", sccboardtab[sccboard].name, minor);
break;
case HW_INF_STAT :
for (minor = cnt = 0, scc = sccchans; minor < sccminors; minor++, scc++)
if (scc->l2port != -1) {
if (cnt++ == 0)
putstr("\rSCC-Statistics:\r\r", mbp);
putprintf(mbp, " SCC%u RxOvr: %5u TxUnd: %5u RxCRC: %5u RxBuf: %5u\r",
minor, scc->overruns, scc->underruns, scc->crcerrors, scc->buferrors);
}
break;
case HW_INF_CLEAR :
scc = &sccchans[minor];
scc->overruns =
scc->underruns =
scc->crcerrors =
scc->lenerrors =
scc->buferrors = 0;
/* durchfallen */
default :
default_l1info(what, port, mbp);
}
}
/* SCC-Modes:
t -> Sendetakt extern (DF9IC)
e -> Sendetakt BRG (32-fach)
-> Sendetakt DPLL (32-fach)
r -> Empfangstakt extern (DF9IC)
-> Empfangstakt DPLL
*/
static void sccput(UWORD action)
{
*sccin++ = action;
if (sccin >= sccbuf+SCC_RXSIZE)
sccin = sccbuf;
}
#define rxput(port, val) sccput (((port) << 8) | (val))
#define rxeof(port, fcs) sccput (((port) << 8) | 0x8000 | (fcs<<1))
#define rxdiscard(port) sccput (((port) << 8) | 0x8001)
/*** SCC Clock **************************************************************/
static void scc_clk (__scc_struct *scc, int tx_on)
{
UWORD tconst;
if (scc->flags & MODE_t) /* externer Takt */
{
WR (11, TRxC_RTxC);
WR (14, DPLL_DIS);
}
else
{
tconst = PCLK / 64L / scc->baud;
if (tx_on)
tconst *= 32;
tconst -= 2;
WR (12, LOBYTE (tconst));
WR (13, HIBYTE (tconst));
WR (11, tx_on ? DPLL_BRG | TRxOUT_BRG
: (scc->flags & MODE_e ? DPLL_RTxC | TRxOUT_BRG
: DPLL_RTxC | TRxOUT_DPLL));
WR (14, DPLL_SRCBRG);
if ((scc->flags & MODE_z) == 0) WR (14, DPLL_NRZI);
WR (14, DPLL_EN);
}
}
/*** SCC TX *****************************************************************/
static void scc_tx (__scc_struct *scc, int tx_on)
{
/* wenn MODE_t nicht gesetzt ist, muessen wir bei TX umschalten */
if ((scc->flags & MODE_t) == 0)
{
WR (3, RX_DIS);
WR (5, TX_DIS);
scc_clk (scc, tx_on);
if (tx_on)
WR (5, TX_EN | RTS);
else
WR (3, RX_EN);
}
else
WR (5, tx_on ? TX_EN | RTS : TX_EN);
}
/*** Timer ******************************************************************/
static void scc_timer (UWORD ticks)
{
__scc_struct *scc;
if (scc_major == 0)
return;
for (scc = sccchans; scc < sccchans+sccminors; scc++)
if (scc->l2port != -1)
{
disable ();
if (scc->tx_timer)
{
if (scc->tx_timer <= ticks)
{
scc->tx_timer = 0;
switch (scc->tx_state)
{
case TX_DWAIT:
if ( (scc->flags & MODE_d)
|| ( (!scc->dcd)
&& ((rand()&0xff) <= scc->persistance)
)
)
{
scc_tx(scc, TRUE);
scc->tx_timer = not0(scc->txdelay);
scc->tx_state = TX_DELAY;
}
else
scc->tx_timer = not0(scc->slottime);
break;
case TX_DELAY:
WR0 (RES_TX_CRC);
WR8 (*scc->tx_ptr++);
WR0 (RES_EOM);
scc->tx_state = TX_ACTIVE;
break;
case TX_TAIL:
scc_tx(scc, FALSE);
scc->tx_state = TX_IDLE;
}
}
else
scc->tx_timer -= ticks;
}
enable ();
}
}
/*** SCC Interrupt **********************************************************/
static void (*handler[]) (__scc_struct *) = {int_tx, int_ex, int_rx, int_sp};
//#define DEBUG(x) _farpokeb(_dos_ds,0xB8000, x);
static void scc_int(int foo)
{
__scc_struct *scc;
UBYTE rr2;
//DEBUG(ch++);
for (scc = sccchans; scc < sccchans+sccminors; )
if (RR (3))
{
scc++;
rr2 = RR (2);
handler[(rr2 >> 1) & 3] (&sccchans[(rr2 >> 3) ^ 1]);
scc = sccchans;
}
else
scc += 2;
}
/*** TX Handler *************************************************************/
static void int_tx(__scc_struct *scc)
{
switch (scc->tx_state)
{
case TX_ACTIVE:
if (RR0 & TX_EOM)
{
scc->underruns++;
scc->errors++;
scc->tx_ptr = scc->tx_buf; /* txrewind */
scc->tx_state = TX_FLUSH;
}
else
if (scc->tx_ptr >= scc->tx_buf + scc->tx_len) /* Frameende? */
{
WR (10, scc->flags & MODE_z ? NRZ : NRZI);
WR0 (RES_TX_IP);
scc->tx_state = TX_FLUSH;
scc->tx_len = 0; /* Frame gesendet */
} else
WR8 (*scc->tx_ptr++);
break;
case TX_FLUSH:
WR (10, scc->flags & MODE_z ? NRZ | ABUNDER : NRZI | ABUNDER);
if (scc->tx_ptr < scc->tx_buf + scc->tx_len) /* noch Daten? */
{
WR0 (RES_TX_CRC);
WR8 (*scc->tx_ptr++);
WR0 (RES_EOM);
scc->tx_state = TX_ACTIVE;
}
else
{
WR0 (RES_TX_IP);
scc->tx_timer = scc->tailtime; /* + clkstep */
scc->tx_state = TX_TAIL;
}
}
}
/*** Extern Status Change ***************************************************/
static void int_ex (__scc_struct *scc)
{
static UBYTE rr0, delta;
delta = (rr0 = RR0) ^ scc->rr0;
if (scc->l2port != -1)
{
if (scc->rx_len && rr0 & (ABORT | HUNT))
{
rxdiscard (scc->chan);
scc->rx_len = 0;
scc->rx_err = FALSE;
}
if (delta & (scc->flags & MODE_c ? HUNT : DCD))
{
scc->dcd = (scc->flags & MODE_c)
? (!(rr0 & HUNT))
: (rr0 & DCD);
}
}
scc->rr0 = rr0;
WR0 (RES_EX_INT);
}
/*** RX Handler *************************************************************/
static void int_rx (__scc_struct *scc)
{
UBYTE rr8;
rr8 = RR8;
if (!scc->rx_err)
{
/* scc->rx_err = */ rxput (scc->chan, rr8);
scc->rx_len++;
}
}
/*** Special RX Condition ***************************************************/
static void int_sp (__scc_struct *scc)
{
UBYTE rr1;
rr1 = RR (1);
RR8;
if (rr1 & RX_OVR)
{
scc->overruns++;
scc->errors++;
scc->rx_err = TRUE;
}
if (rr1 & SDLC_EOF)
{
if ( !scc->rx_err
&& scc->rx_len >= MIN_LEN+1
&& (rr1 & (CRC_ERR | RESIDUE)) == RES8)
{
rxeof (scc->chan, 1);
}
else
if (scc->rx_len) {
rxdiscard (scc->chan);
/*if (scc->rx_len > 2) {
if (scc->rx_len < MIN_LEN+1) scc->lenerrors++;
if ((rr1 & (CRC_ERR | RESIDUE)) != RES8) scc->crcerrors++;
}*/
}
scc->rx_len = 0;
scc->rx_err = FALSE;
}
WR0 (RES_ERR);
}
/*** SCC Hardware Reset *****************************************************/
static void scc_hw_reset (void)
{
__scc_struct *scc;
UWORD delay;
for (scc = sccchans; scc < &sccchans[sccminors]; scc += 2)
{
RR0;
WR (9, HW_RES);
for (delay = 100; delay--;) SCCDELAY;
}
}
/*** SCC Detect *************************************************************/
static int scc_detect(int max)
{
__scc_struct *scc;
for (scc = sccchans; scc < sccchans+max; scc++)
{
RR0;
WR (13, 0x55); if (RR (13) != 0x55) break;
WR (13, 0xAA); if (RR (13) != 0xAA) break;
}
return((int) (scc - sccchans));
}
/* Boardtyp auswaehlen, Defaultparameter setzen */
static int scc_init(void)
{
char *str;
__scc_board *board;
__scc_struct *scc;
int chan;
for (sccboard = 0, board = sccboardtab; board->name; board++, sccboard++) {
if ((str = getenv(board->name)) != NULL) {
sccbase = board->base;
sccirq = board->irq;
sscanf(str, "%x,%u", &sccbase, &sccirq);
if (sccbase && sccirq) {
if ((sccbuf = malloc(SCC_RXSIZE*sizeof(UWORD))) == NULL)
return(0);
sccin = sccout = sccbuf;
for (chan = 0, scc = sccchans; chan < SCCCHANS; chan++, scc++) {
scc->l2port = -1;
scc->rxfhd = NULL;
scc->chan = chan;
scc->data = sccbase + board->data[chan];
scc->ctrl = scc->data + board->ctrl;
if ((scc->tx_buf = malloc(SCC_TXSIZE)) == NULL) {
while (--scc >= sccchans)
free(scc->tx_buf);
free(sccbuf);
return(0);
}
scc->tx_len = 0;
}
scc_hw_reset();
disable(); /* Interrupt aus */
allocirq(sccirq, 0, scc_int, 0); /* neuen Vektor setzen */
sccoldmask = getmask(sccirq);
maskon(sccirq);
enable();
xprintf("--- /dev/SCC (0x%03X,IRQ%u), ", sccbase, sccirq);
sccminors = scc_detect(board->chans);
if ((sccminors & 1) == 0) {
if (sccminors) {
printf("card is %s, %u channels\n", board->name, sccminors);
return(1);
} else xprintf("%s not detected\n", board->name);
} else xprintf("channel number is odd\n");
}
}
}
return(0); /* keine Karte gefunden/konfiguriert */
}
static void scc_exit(void)
{
if (scc_major) {
if (sccoldmask) maskoff(sccirq);
freeirq(sccirq);
scc_hw_reset();
}
}
static int register_scc(void)
{
MAJOR *m;
if (scc_init()) {
m = register_major();
m->name = "USCC/DSCC/OSCC";
m->istome = scc_istome;
m->exit = scc_exit;
m->handle = scc;
m->ctl = scc_ctl;
m->dcd = scc_dcd;
m->attach = scc_attach;
m->detach = scc_detach;
m->info = scc_info;
m->timer = scc_timer;
return(scc_major = num_major);
}
return(0);
}
/* End of os/go32/scc.c */
Reference in New Issue View Git Blame Copy Permalink