home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 5 / DATAFILE_PDCD5.iso / internet / netlite2 / DCI / c / MAIN < prev    next >
Encoding:
Text File  |  1993-04-27  |  11.4 KB  |  484 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "kernel.h"
  5. #include "swis.h"
  6. #include "global.h"
  7.  
  8. static _kernel_oserror error;
  9.  
  10. char bcast_hwaddr[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
  11. struct port port[4];
  12.  
  13. struct mbuf   *rxfreeq_first = NULLMBUF;
  14. struct mbuf   *rxfreeq_last  = NULLMBUF;
  15.  
  16. struct mbuf   *txfreeq_first = NULLMBUF;
  17. struct mbuf   *txfreeq_last  = NULLMBUF;
  18.  
  19. struct mbuf   *lfreeq   = NULLMBUF;
  20.  
  21. struct packet *tx_first = NULLPACKET;
  22. struct packet *tx_last  = NULLPACKET;
  23.  
  24. int tx = FALSE;
  25.  
  26. int nounits = 0;
  27. int swibase = 0;
  28.  
  29. int Driver_State = DRIVER_NONE;
  30.  
  31. /* Errors */
  32. int memout  = 0;
  33. int txqfull = 0;
  34. int rxqfull = 0;
  35.  
  36. extern int dci_event_entry(_kernel_swi_regs *, void *);
  37. extern int dci_timer_entry(_kernel_swi_regs *, void *);
  38. static void *private_pw;
  39.  
  40. void dci_finalisation(void)
  41. {
  42.        _kernel_swi_regs rin, rout;
  43.  
  44.        rin.r[0] = 13;
  45.        rin.r[1] = EVENT_TX;
  46.        _kernel_swi(XOS_Bit | OS_Byte, &rin, &rout);
  47.  
  48.        rin.r[0] = 13;
  49.        rin.r[1] = EVENT_RX;
  50.        _kernel_swi(XOS_Bit | OS_Byte, &rin, &rout);
  51.  
  52.        rin.r[0] = 0x10;
  53.        rin.r[1] = (int)dci_event_entry;
  54.        rin.r[2] = (int)private_pw;
  55.        _kernel_swi(XOS_Bit | OS_Release, &rin, &rout);
  56.  
  57.        rin.r[0] = 0x1C;
  58.        rin.r[1] = (int)dci_timer_entry;
  59.        rin.r[2] = (int)private_pw;
  60.        _kernel_swi(XOS_Bit | OS_Release, &rin, &rout);
  61.  
  62.        rin.r[1] = Service_ProtocolDying;
  63.        rin.r[2] = 1;
  64.        _kernel_swi(XOS_Bit | OS_ServiceCall, &rin, &rout);
  65. }
  66.  
  67. _kernel_oserror *dci_initialise(char *cmd, int base, void *pw)
  68. {
  69.        _kernel_swi_regs rin, rout;
  70.        register int i;
  71.        static int claimed = FALSE;
  72.  
  73.        cmd  = cmd;
  74.        base = base;
  75.  
  76.        private_pw = pw;
  77.  
  78.        atexit(dci_finalisation);
  79.  
  80.        for (i = 0; i < 4; i++)
  81.        {
  82.                port[i].status   = STATUS_NODRVR;
  83.                port[i].ipaddr   = 0;
  84.                port[i].rx_first = NULLPACKET;
  85.                port[i].rx_last  = NULLPACKET;
  86.                port[i].iprx     = port[i].iptx     = 0;
  87.                port[i].arpreqrx = port[i].arpreqtx = 0;
  88.                port[i].arpresrx = port[i].arprestx = 0;
  89.        }
  90.  
  91.        initialise_rx_mbuf(400);
  92.        initialise_tx_mbuf(300);
  93.        initialise_packet();
  94.        Initialise_ARP_Cache();
  95.  
  96.        rin.r[1] = Service_FindNetworkDriver;
  97.        rin.r[2] = 0;
  98.        rin.r[3] = 0;
  99.        _kernel_swi(XOS_Bit | OS_ServiceCall, &rin, &rout);
  100.  
  101.        if (rout.r[1] == 0)
  102.        {
  103.                Attach_Driver();
  104.  
  105.                if (Driver_State != DRIVER_INITED)
  106.                {
  107.                       error.errnum = 3;
  108.                       strcpy(error.errmess, "Could not attach driver");
  109.                       return(&error);
  110.                }
  111.        }
  112.  
  113.        if (!claimed)
  114.        {
  115.                rin.r[0] = 0x1C;
  116.                rin.r[1] = (int)dci_timer_entry;
  117.                rin.r[2] = (int)private_pw;
  118.                _kernel_swi(XOS_Bit | OS_Claim, &rin, &rout);
  119.  
  120.                rin.r[0] = 0x10;
  121.                rin.r[1] = (int)dci_event_entry;
  122.                rin.r[2] = (int)private_pw;
  123.                _kernel_swi(XOS_Bit | OS_Claim, &rin, &rout);
  124.  
  125.                rin.r[0] = 14;
  126.                rin.r[1] = EVENT_TX;
  127.                _kernel_swi(XOS_Bit | OS_Byte, &rin, &rout);
  128.  
  129.                rin.r[0] = 14;
  130.                rin.r[1] = EVENT_RX;
  131.                _kernel_swi(XOS_Bit | OS_Byte, &rin, &rout);
  132.  
  133.                claimed = TRUE;
  134.        }
  135.  
  136.        return(NULL);
  137. }
  138.  
  139. void Attach_Driver(void)
  140. {
  141.        _kernel_swi_regs rin, rout;
  142.        struct dib *dib;
  143.        struct pib pib;
  144.        register int i;
  145.  
  146.        pib.pib_frtypecnt = 2;
  147.        pib.pib_frtype[0] = FRAME_IP;
  148.        pib.pib_frtype[1] = FRAME_ARP;
  149.        pib.pib_rxevent   = EVENT_RX;
  150.        pib.pib_freeq     = &rxfreeq_first;
  151.        pib.pib_sccall    = 1;
  152.        pib.pib_lfreeq    = &lfreeq;
  153.  
  154.        rin.r[1] = Service_FindNetworkDriver;
  155.        rin.r[2] = (int)"ea";
  156.        rin.r[3] = (int)&pib;
  157.        _kernel_swi(XOS_Bit | OS_ServiceCall, &rin, &rout);
  158.  
  159.        if (rout.r[1] != 0) return;
  160.  
  161.        dib = (struct dib *)rout.r[3];
  162.  
  163.        nounits = dib->dib_units;
  164.        swibase = dib->dib_swibase;
  165.  
  166.        for (i = 0; i < nounits; i++)
  167.        {
  168.               port[i].status    = STATUS_DOWN;
  169.               port[i].hwaddr[0] = dib->dib_address[i][0];
  170.               port[i].hwaddr[1] = dib->dib_address[i][1];
  171.               port[i].hwaddr[2] = dib->dib_address[i][2];
  172.               port[i].hwaddr[3] = dib->dib_address[i][3];
  173.               port[i].hwaddr[4] = dib->dib_address[i][4];
  174.               port[i].hwaddr[5] = dib->dib_address[i][5];
  175.  
  176.               rin.r[0] = i;
  177.               _kernel_swi(XOS_Bit | (swibase + SWI_NetworkIfStart), &rin, &rout);
  178.  
  179.               rin.r[0] = i;
  180.               _kernel_swi(XOS_Bit | (swibase + SWI_NetworkIfDown), &rin, &rout);
  181.        }
  182.  
  183.        Driver_State = DRIVER_INITED;
  184. }
  185.  
  186. void dci_service(int snum, _kernel_swi_regs *r, void *pw)
  187. {
  188.        int i;
  189.  
  190.        snum = snum;
  191.        pw = pw;
  192.  
  193.        switch (r->r[2])
  194.        {
  195.                case 0:
  196.                     Attach_Driver();
  197.                     break;
  198.                case 1:
  199.                     Driver_State = DRIVER_NONE;
  200.                     for (i = 0; i < 4; i++)
  201.                           port[i].status = STATUS_NODRVR;
  202.                     break;
  203.                default:
  204.                     break;
  205.        }
  206. }
  207.  
  208. _kernel_oserror *dci_command(char *arg, int argc, int cmd, void *pw)
  209. {
  210.        arg  = arg;
  211.        argc = argc;
  212.        pw   = pw;
  213.  
  214.        printf("Statistics for DCI Driver\n");
  215.  
  216.        switch (cmd)
  217.        {
  218.              case COMMAND_PORT:
  219.                     Port_Stats();
  220.                     break;
  221.              case COMMAND_ARP:
  222.                     ARP_Stats();
  223.                     break;
  224.              case COMMAND_QUEUE:
  225.                     Queue_Stats();
  226.                     break;
  227.              case COMMAND_ERROR:
  228.                     Error_Stats();
  229.                     break;
  230.              default:
  231.                     break;
  232.        }
  233.  
  234.        printf("\n");
  235.  
  236.        return(NULL);
  237. }
  238.  
  239. _kernel_oserror *dci_swi(int swino, _kernel_swi_regs *r, void *pw)
  240. {
  241.        pw = pw;
  242.  
  243.        switch (swino)
  244.        {
  245.                case NETLITE_OPEN:
  246.                       Open_Port(r);
  247.                       break;
  248.                case NETLITE_READ:
  249.                       Read_Port(r);
  250.                       break;
  251.                case NETLITE_WRITE:
  252.                       Write_Port(r);
  253.                       break;
  254.                case NETLITE_CLOSE:
  255.                       Close_Port(r);
  256.                       break;
  257.                default:
  258.                       error.errnum = 1;
  259.                       strcpy(error.errmess, "Invalid SWI");
  260.                       return(&error);
  261.                      
  262.        }
  263.  
  264.        return(NULL);
  265. }
  266.  
  267. int dci_event_handler(_kernel_swi_regs *r, void *pw)
  268. {
  269.        pw = pw;
  270.  
  271.        switch (r->r[0])
  272.        {
  273.                 case EVENT_RX:
  274.                        Receive_Upcall(r);
  275.                        break;
  276.                 case EVENT_TX:
  277.                        Transmit_Upcall(r);
  278.                        break;
  279.                 default:
  280.                        break;
  281.        }
  282.  
  283.        return(1);
  284. }
  285.  
  286. int dci_timer_handler(_kernel_swi_regs *r, void *pw)
  287. {
  288.        pw = pw;
  289.        r  = r;
  290.  
  291.        Timeout_ARP_Cache();
  292.  
  293.        if (!tx && tx_first != NULLPACKET)
  294.               Transmit_Packet();
  295.  
  296.        return(1);
  297. }
  298.  
  299. void Open_Port(register _kernel_swi_regs *r)
  300. {
  301.        _kernel_swi_regs rin, rout;
  302.        register int portno = r->r[0];
  303.  
  304.        if (Driver_State == DRIVER_NONE)
  305.        {
  306.                r->r[1] = SWI_NODRIVER;
  307.                return;
  308.        }
  309.  
  310.        if (portno < 0 || portno >= nounits)
  311.        {
  312.                r->r[1] = SWI_INVPORT;
  313.                return;
  314.        }
  315.  
  316.        if (port[portno].status == STATUS_UP)
  317.        {
  318.                r->r[1] = SWI_OK;
  319.                return;
  320.        }
  321.  
  322.        if (port[portno].status != STATUS_DOWN)
  323.        {
  324.                r->r[1] = SWI_OPEN;
  325.                return;
  326.        }
  327.  
  328.        port[portno].status = STATUS_UP;
  329.        port[portno].ipaddr = r->r[1];
  330.  
  331.        rin.r[0] = portno;
  332.        _kernel_swi(XOS_Bit | (swibase + SWI_NetworkIfUp), &rin, &rout);
  333.  
  334.        r->r[1] = SWI_OK;
  335. }
  336.  
  337. void Close_Port(_kernel_swi_regs *r)
  338. {
  339.        _kernel_swi_regs rin, rout;
  340.        register int portno = r->r[0];
  341.  
  342.        if (Driver_State == DRIVER_NONE)
  343.        {
  344.                r->r[1] = SWI_NODRIVER;
  345.                return;
  346.        }
  347.  
  348.        if (portno < 0 || portno >= nounits)
  349.        {
  350.                r->r[1] = SWI_INVPORT;
  351.                return;
  352.        }
  353.  
  354.        if (port[portno].status == STATUS_DOWN)
  355.        {
  356.                r->r[1] = SWI_OK;
  357.                return;
  358.        }
  359.  
  360.        if (port[portno].status != STATUS_UP)
  361.        {
  362.                r->r[1] = SWI_CLOSED;
  363.                return;
  364.        }
  365.  
  366.        port[portno].status = STATUS_DOWN;
  367.  
  368.        rin.r[0] = portno;
  369.        _kernel_swi(XOS_Bit | (swibase + SWI_NetworkIfDown), &rin, &rout);
  370.  
  371.        r->r[1] = SWI_OK;
  372. }
  373.  
  374. void Port_Stats(void)
  375. {
  376.        register int i;
  377.  
  378.        for (i = 0; i < nounits; i++)
  379.        {
  380.                if (port[i].status != STATUS_NODRVR)
  381.                {
  382.                        printf("Port:%d  HwAddr:%02X:%02X:%02X:%02X:%02X:%02X  State:%s\n", i,
  383.                                port[i].hwaddr[0], port[i].hwaddr[1], port[i].hwaddr[2],
  384.                                port[i].hwaddr[3], port[i].hwaddr[4], port[i].hwaddr[5],
  385.                                (port[i].status == STATUS_UP) ? "UP" : "DOWN");
  386.                        printf("IP In:%d  IP Out:%d\n", port[i].iprx,  port[i].iptx);
  387.                        printf("ARP Request In:%d  ARP Request Out:%d\n",   port[i].arpreqrx,  port[i].arpreqtx);
  388.                        printf("ARP Response In:%d  ARP Response Out:%d\n", port[i].arpresrx,  port[i].arprestx);
  389.                }
  390.        }
  391. }
  392.  
  393. void Queue_Stats(void)
  394. {
  395.        register struct mbuf *bp;
  396.        register int i, n;
  397.  
  398.        printf("TX Port: Packets:%d\n", len_q(tx_first));
  399.  
  400.        for (i = 0; i < 4; i++)
  401.              if (port[i].status == STATUS_UP)
  402.                        printf("RX Port:%d Packets:%d\n", i, len_q(port[i].rx_first));
  403.  
  404.        i = n = 0;
  405.        for (bp = rxfreeq_first; bp != NULLMBUF; bp = bp->m_next)
  406.        {
  407.              if (bp->m_type == MT_DATA)
  408.              {
  409.                     i++;
  410.                     printf("mbuf %d in use\n", n);
  411.              }
  412.  
  413.              n++;
  414.        }
  415.  
  416.        printf("RX Free queue=%d mbufs, %d K, %d used\n", n, n * MLEN, i);
  417.  
  418.        i = n = 0;
  419.        for (bp = txfreeq_first; bp != NULLMBUF; bp = bp->m_next)
  420.        {
  421.              if (bp->m_type == MT_DATA)
  422.              {
  423.                     i++;
  424.                     printf("mbuf %d in use\n", n);
  425.              }
  426.  
  427.              n++;
  428.        }
  429.  
  430.        printf("TX Free queue=%d mbufs, %d K, %d used\n", n, n * MLEN, i);
  431. }
  432.  
  433. void Error_Stats(void)
  434. {
  435.        printf("Out of Memory:%d\n", memout);
  436.        printf("TX queue full:%d\n", txqfull);
  437.        printf("RX queue full:%d\n", rxqfull);
  438. }
  439.  
  440. char *put32(register char *cp, int x)
  441. {
  442.         *cp++ = (char)(x >> 24);
  443.         *cp++ = (char)(x >> 16);
  444.         *cp++ = (char)(x >> 8);
  445.         *cp++ = (char)(x);
  446.  
  447.         return(cp);
  448. }
  449.  
  450. char *put16(register char *cp, short x)
  451. {
  452.         *cp++ = (char)(x >> 8);
  453.         *cp++ = (char)(x);
  454.  
  455.         return(cp);
  456. }
  457.  
  458. short get16(register char *cp)
  459. {
  460.         register short x;
  461.  
  462.         x = (char)(*cp++);
  463.         x <<= 8;
  464.         x |= (char)(*cp);
  465.  
  466.         return(x);
  467. }
  468.  
  469. int get32(register char *cp)
  470. {
  471.         register int x;
  472.  
  473.         x = (char)(*cp++);
  474.         x <<= 8;
  475.         x |= (char)(*cp++);
  476.         x <<= 8;
  477.         x |= (char)(*cp++);
  478.         x <<= 8;
  479.         x |= (char)(*cp);
  480.  
  481.         return(x);
  482. }
  483.  
  484.