home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 4 / CDPD_IV.bin / networking / tcpip / amitcp-support / plip / source / plip.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-04  |  26.4 KB  |  1,215 lines
  1. /*
  2.  * PLIP.device - Parallel Line Internet Protocol
  3.  *
  4.  * A SANA2 networking device driver for two Amigas connected via their
  5.  * parallel ports.
  6.  *
  7.  * By Oliver Wagner with a little assistance of Michael Balzer.
  8.  * Copyright (c) 1993-1994 Oliver Wagner and Michael Balzer.
  9.  *
  10.  */
  11.  
  12. #include <proto/dos.h>
  13. #include <proto/exec.h>
  14. #include <proto/cia.h>
  15. #include <proto/misc.h>
  16. #include <proto/utility.h>
  17. #include <proto/timer.h>
  18. #include <devices/sana2.h>
  19. #include <hardware/cia.h>
  20. #include <resources/misc.h>
  21. #include <exec/memory.h>
  22. #include <dos/dostags.h>
  23. #include <string.h>
  24.  
  25. #define min __builtin_min
  26. #define max __builtin_max
  27. #define abs __builtin_abs
  28.  
  29. #define SERVER_TASK        "PLIP Server Task"
  30.  
  31. #define PLIP_MTU        8192
  32. #define PLIP_DEFMTU        1024
  33. #define PLIP_BPS        15000
  34. #define PLIP_HWTYPE        13
  35. #define PLIP_RETRIES    63
  36.  
  37. LONG plip_bps     = PLIP_BPS;
  38. LONG plip_mtu     = PLIP_DEFMTU;
  39. LONG plip_retries = PLIP_RETRIES;
  40.  
  41. #define ios2_Error ios2_Req.io_Error
  42. #define ios2_Flags ios2_Req.io_Flags
  43.  
  44. #define PKTFRAMESIZE 8
  45.  
  46. struct intdata {
  47. /*0*/    USHORT mode,pad1;
  48. /*4*/    ULONG recsig;            /* signals for receive */
  49. /*8*/    struct Task *sigtask;    /* device task to signal */
  50. /*12*/  struct ExecBase *SysBase; /* local sysbase copy for interrupt */
  51. };
  52.  
  53. struct sendframe {
  54.     long sync;
  55.     short size;
  56.     unsigned short crc;
  57.     long pkt;
  58.     unsigned char data[PLIP_MTU];
  59. } sendframe, receiveframe;
  60.  
  61. #define SYNCBYTE 0x42
  62.  
  63. struct trackrec {
  64.     struct MinNode n;
  65.     ULONG packettype;
  66.     struct Sana2PacketTypeStats s2ps;
  67. };    
  68.  
  69. struct MyDev {
  70.     struct Library l;
  71.     UBYTE flags, pad;
  72.     APTR seglist;
  73. };
  74.  
  75. struct BufRoutines {
  76.     long __asm (*CopyToBuff)(register __a0 void*,register __a1 void*,register __d0 long);
  77.     long __asm (*CopyFromBuff)(register __a0 void*,register __a1 void*,register __d0 long);
  78. };
  79.  
  80. extern far volatile struct CIA ciaa,ciab;
  81.  
  82. __aligned struct Library *MiscBase, *CIAABase;
  83. struct Library *UtilityBase, *TimerBase;
  84. struct DosLibrary *DOSBase;
  85. struct ExecBase *SysBase;
  86.  
  87. static __aligned struct intdata intdata;
  88. static __aligned struct Interrupt intstruc;
  89. static long allocflags;
  90. static struct MsgPort *serverport, *timerport;
  91. static __aligned struct Sana2DeviceStats devstats; /* device stats */
  92. static __aligned struct timerequest treq;
  93. static __aligned struct List readlist, writelist, eventlist, readorphanlist, tracklist;
  94. static __aligned struct SignalSemaphore eventlistsem, writelistsem, tracklistsem;
  95.  
  96. #define FLG_CLIENT            1    /* client mode */
  97. #define FLG_EXCLUSIVE        2    /* current opener is exclusive */
  98. #define FLG_NOTCONFIGURED    4    /* not configured */
  99. #define FLG_OFFLINE            8
  100. #define ISOFFLINE            (devflags & (FLG_OFFLINE | FLG_NOTCONFIGURED))
  101. static long                    devflags = FLG_NOTCONFIGURED;    /* current flags */
  102.  
  103. #define IM_CLIENT            1    /* client mode */
  104. #define IM_SEND                2    /* sending pkt */
  105. #define IM_REC                4    /* receiving */
  106. #define IM_GETHEADER        8    /* got 1 char */
  107. #define IM_BUFF2            16    /* just filled second buffer */
  108. #define IM_RXERROR            32    /* receive error */
  109. #define IM_GOTSYNC            64
  110.  
  111. extern void intcode(void);
  112. extern void __asm settimeout(register __d0 ULONG timeout);
  113. extern void __asm parinit(register __d0 int);
  114. extern long __asm testbusy(void), testpout(void);
  115. extern void __asm setbusy(register __d0 long), setpout(register __d0 long);
  116.  
  117. extern long __asm waitinputtoggle(void);
  118. extern void __asm setciaoutput(void);
  119. extern void __asm outputtoggle(void);
  120. extern void __asm sampleinput(void);
  121.  
  122. extern USHORT __asm CRC16( register __a0 UBYTE *, register __d0 SHORT );
  123.  
  124. /***********************************************************
  125.  * TRACKTYPE support
  126.  */
  127.  
  128. static struct trackrec * __inline findtracktype( ULONG type )
  129. {
  130.     struct trackrec * tr = ( struct trackrec * ) tracklist.lh_Head;
  131.  
  132.     while( tr->n.mln_Succ )
  133.     {
  134.         if( tr->packettype == type )
  135.             return( tr );
  136.         tr = ( struct trackrec * ) tr->n.mln_Succ;
  137.     }
  138.  
  139.     return( NULL );
  140. }
  141.  
  142. static int addtracktype( ULONG type )
  143. {
  144.     struct trackrec *tr;
  145.  
  146.     ObtainSemaphore( &tracklistsem );
  147.     tr = findtracktype( type );
  148.     if( tr )
  149.     {
  150.         ReleaseSemaphore( &tracklistsem );
  151.         return( -1 );
  152.     }
  153.     else
  154.     {
  155.         tr = AllocMem( sizeof( *tr ), MEMF_CLEAR );
  156.         if( !tr )
  157.         {
  158.             ReleaseSemaphore( &tracklistsem );
  159.             return( -2 );
  160.         }
  161.         tr->packettype = type;
  162.         AddTail( &tracklist, ( struct Node * ) tr );
  163.     }
  164.  
  165.     ReleaseSemaphore( &tracklistsem );
  166.     return( 0 );
  167. }
  168.  
  169. static int remtracktype( ULONG type )
  170. {
  171.     struct trackrec *tr;
  172.  
  173.     ObtainSemaphore( &tracklistsem );
  174.  
  175.     tr = findtracktype( type );
  176.     if( tr )
  177.     {
  178.         Remove( ( struct Node * ) tr );
  179.         FreeMem( tr, sizeof( *tr ) );
  180.         ReleaseSemaphore( &tracklistsem );
  181.         return( 0 );
  182.     }
  183.     ReleaseSemaphore( &tracklistsem );
  184.     return( -1 );
  185. }
  186.  
  187. static void __inline dotracktype( ULONG type, ULONG ps, ULONG pr, ULONG bs, ULONG br, ULONG pd )
  188. {
  189.     struct trackrec * tr;
  190.  
  191.     ObtainSemaphoreShared( &tracklistsem );
  192.     tr = findtracktype( type );    
  193.     if( tr )
  194.     {
  195.         tr->s2ps.PacketsSent += ps;
  196.         tr->s2ps.PacketsReceived += pr;
  197.         tr->s2ps.BytesSent += bs;
  198.         tr->s2ps.BytesReceived += br;
  199.         tr->s2ps.PacketsDropped += pd;
  200.     }
  201.     ReleaseSemaphore( &tracklistsem );
  202. }
  203.  
  204. static int gettrackrec( ULONG type, APTR info )
  205. {
  206.     struct trackrec * tr;
  207.  
  208.     ObtainSemaphoreShared( &tracklistsem );
  209.     tr = findtracktype( type );    
  210.     if( tr )
  211.     {
  212.         memcpy( info, &tr->s2ps, sizeof( tr->s2ps ) );
  213.         ReleaseSemaphore( &tracklistsem );
  214.         return( 0 );
  215.     }
  216.     ReleaseSemaphore( &tracklistsem );
  217.     return( -1 );
  218. }
  219.  
  220. /***********************************************************
  221.  * CIA Zugriff
  222.  */
  223.  
  224. static void __inline writecia( unsigned char val )
  225. {
  226.     ciaa.ciaprb = val;
  227. }
  228.  
  229. static unsigned char __inline readciabyte( void )
  230. {
  231.     return( ciaa.ciaprb );
  232. }
  233.  
  234.  
  235. /***********************************************************
  236.  * Event-Handling: Alle Event-Requests zurückschicken,
  237.  * die auf das eingetretene Ereignis passen.
  238.  */
  239.  
  240. void DoEvent( long event )
  241. {
  242.     struct IOSana2Req *ior, *ior2;
  243.  
  244.     ObtainSemaphore( &eventlistsem );
  245.     
  246.     for( ior = (struct IOSana2Req *) eventlist.lh_Head;
  247.          ior2 = (struct IOSana2Req *) ior->ios2_Req.io_Message.mn_Node.ln_Succ;
  248.          ior = ior2 )
  249.     {
  250.         if( ior->ios2_WireError & event )
  251.         {
  252.             Remove( ior );
  253.             ReplyMsg( ior );
  254.         }
  255.     }
  256.     
  257.     ReleaseSemaphore( &eventlistsem );
  258. }
  259.  
  260.  
  261. /***********************************************************
  262.  * Interrupt Support
  263.  */
  264.  
  265. static void __inline disableint( void )
  266. {
  267.     AbleICR( CIAABase, CIAICRF_FLG );
  268. }
  269.  
  270. static void __inline enableint( void )
  271. {
  272.     AbleICR( CIAABase, CIAICRF_FLG | CIAICRF_SETCLR );
  273. }
  274.  
  275.  
  276. static long setupint( void )
  277. {
  278.     MiscBase = OpenResource( "misc.resource" );
  279.     CIAABase = OpenResource( "ciaa.resource" );
  280.  
  281.     /* Parallel-Port allokieren */
  282.     if( AllocMiscResource( MR_PARALLELPORT, "plip.device" ) ) return 1;
  283.     allocflags |= 1;
  284.     if( AllocMiscResource( MR_PARALLELBITS, "plip.device" ) ) return 2;
  285.     allocflags |= 2;
  286.  
  287.     intstruc.is_Node.ln_Type = NT_INTERRUPT;
  288.     intstruc.is_Node.ln_Pri  = 0;
  289.     intstruc.is_Node.ln_Name = "PLIP PORTS Interrupt";
  290.     intstruc.is_Data         = &intdata;
  291.     intstruc.is_Code         = intcode;
  292.  
  293.     /* Interrupt einfügen */
  294.     Disable();
  295.     {
  296.         /* Parallel-Port initialisieren */
  297.         parinit( intdata.mode & IM_CLIENT );
  298.         
  299.         if( AddICRVector( CIAABase, CIAICRB_FLG, &intstruc ) )
  300.         {
  301.             Enable();
  302.             return 3;
  303.         }
  304.         
  305.         allocflags |= 4;
  306.     }
  307.     Enable();
  308.  
  309.     enableint();
  310.     
  311.     return 0;
  312. }
  313.  
  314. static void cleanupint( void )
  315. {
  316.     if( allocflags & 4 ) RemICRVector( CIAABase, CIAICRB_FLG, &intstruc );
  317.     if( allocflags & 2 ) FreeMiscResource( MR_PARALLELBITS );
  318.     if( allocflags & 1 ) FreeMiscResource( MR_PARALLELPORT );
  319.     allocflags = 0;
  320. }
  321.  
  322.  
  323. /***********************************************************
  324.  * WRITE
  325.  *
  326.  * Der Leser steuert über POUT (bzw. BUSY) die Übertragung.
  327.  * Init: Schreiber schreibt Byte 1, was beim Leser einen Interrupt
  328.  * auslöst. Der Leser quittiert den Empfang jedes Bytes mit einem Wechsel
  329.  * der Handshake-Leitung, der Schreiber zeigt dem Leser durch Wechsel
  330.  * der anderen Handshake-Leitung an, wenn ein Byte bereit steht.
  331.  *
  332.  * Um Deadlocks zu vermeiden (race condition) wird _einmal_ _vor_ der
  333.  * Übertragung der Zustand des Handshakes eingelesen und dann immer
  334.  * nur noch ohne vorherigen Lesezugriff auf den Wechsel gewartet.
  335.  */
  336.  
  337. /* Falls beim Warten auf die Lesebestätigung ein Timeout passiert: */
  338. #define ABORTWRITE { \
  339.     DoEvent( S2EVENT_ERROR | S2EVENT_TX ); \
  340.     intdata.mode &= ~IM_SEND; \
  341.     parinit( intdata.mode & IM_CLIENT ); \
  342.     enableint(); \
  343.     return(-1); }
  344.  
  345. static long procwrite( unsigned char *data, long size )
  346. {
  347.     /* Init */
  348.     disableint();
  349.     setciaoutput();
  350.     
  351.     /* aktuellen Stand der Handshake-Leitung samplen */
  352.     sampleinput();
  353.     
  354.     /* Übertragung anstoßen */
  355.     writecia( *data++ );
  356.  
  357.     while( --size )
  358.     {
  359.         if( !waitinputtoggle() ) ABORTWRITE;
  360.         writecia( *data++ );
  361.         outputtoggle();
  362.     }
  363.  
  364.     /* Bestätigung für letztes Byte abwarten */
  365.     if( !waitinputtoggle() ) ABORTWRITE;
  366.     
  367.     /* Ok. */
  368.     intdata.mode &= ~IM_SEND;
  369.     parinit( intdata.mode & IM_CLIENT );
  370.     enableint();
  371.     devstats.PacketsSent++;
  372.  
  373.     return 0;
  374. }
  375.  
  376.  
  377. /***********************************************************
  378.  * READ
  379.  *
  380.  * Wird vom Interrupt aus angestoßen.
  381.  */
  382.  
  383. /* Falls beim Warten auf das nächste Byte ein Timeout passiert: */
  384. #define ABORTREAD { \
  385.     devstats.BadData++; \
  386.     DoEvent( S2EVENT_ERROR | S2EVENT_RX ); \
  387.     intdata.mode &= ~IM_REC; \
  388.     parinit( intdata.mode & IM_CLIENT ); \
  389.     enableint(); \
  390.     return; }
  391.  
  392. static void procread( void )
  393. {
  394.     unsigned short crc;
  395.     short len;
  396.     int l;
  397.     long bufferror,pkttyp;
  398.  
  399.     struct IOSana2Req *got, *ro;
  400.     unsigned char *d, ch;
  401.  
  402.     /* Init */
  403.     disableint();
  404.     sampleinput();
  405.     
  406.     /* SYNC? */
  407.     if( readciabyte() != 0x42 ) ABORTREAD;
  408.     
  409.     /* restliche SYNC-Bytes überlesen */
  410.     for(;;)
  411.     {
  412.         outputtoggle();
  413.         if( !waitinputtoggle() ) ABORTREAD;
  414.         
  415.         if( (ch = readciabyte()) != 0x42 )
  416.             break;
  417.     }
  418.  
  419.     /* Größe des Packets einlesen */
  420.     d = (unsigned char *) &receiveframe.size;
  421.     *d++ = ch;
  422.     outputtoggle();
  423.     
  424.     if( !waitinputtoggle() ) ABORTREAD;
  425.     *d++ = readciabyte();
  426.     outputtoggle();
  427.  
  428.     /* Packetgröße sinnvoll? */
  429.     len = receiveframe.size;
  430.     if( len < 6 || len > plip_mtu+6 ) ABORTREAD;
  431.  
  432.     /* len Bytes einlesen */
  433.     while( len-- )
  434.     {
  435.         if( !waitinputtoggle() ) ABORTREAD;
  436.         *d++ = readciabyte();
  437.         outputtoggle();
  438.     }
  439.     
  440.     /* fertig mit Lesen */
  441.     intdata.mode &= ~IM_REC;
  442.  
  443.     /* Exit */
  444.     parinit( intdata.mode & IM_CLIENT );
  445.     enableint();
  446.     
  447.     /* CRC check */
  448.     pkttyp = receiveframe.pkt;
  449.     l = receiveframe.size - 6;
  450.     d = receiveframe.data;
  451.  
  452.     crc = CRC16( d, l );
  453.  
  454.     if( crc == receiveframe.crc )
  455.     {
  456.         /* CRC OK! */
  457.  
  458.         devstats.PacketsReceived++;
  459.  
  460.         dotracktype( pkttyp, 0, 1, 0, l, 0 );
  461.         
  462.         for( got = (struct IOSana2Req *) readlist.lh_Head;
  463.              got && got->ios2_Req.io_Message.mn_Node.ln_Succ;
  464.              got = (struct IOSana2Req *) got->ios2_Req.io_Message.mn_Node.ln_Succ )
  465.         {
  466.             if( got->ios2_PacketType == pkttyp )
  467.             {
  468.                 /* Hurra, der will's haben! */
  469.                 Remove( got );
  470.                 
  471.                 /* Daten kopieren */
  472.                 bufferror = ((struct BufRoutines *) got->ios2_BufferManagement)
  473.                     -> CopyToBuff( got->ios2_Data, receiveframe.data, receiveframe.size - 6 );
  474.                 
  475.                 /* Fehler? */
  476.                 if( !bufferror )
  477.                 {
  478.                     got->ios2_Error     = S2ERR_SOFTWARE;
  479.                     got->ios2_WireError = S2WERR_BUFF_ERROR;
  480.                 }
  481.                 else
  482.                 {
  483.                     got->ios2_Error = got->ios2_WireError = 0;
  484.                 }
  485.  
  486.                 /* Request befriedigen */
  487.                 got->ios2_Flags      = 0;
  488.                 got->ios2_SrcAddr[0] = (devflags & FLG_CLIENT) ?  0     : (1<<7);
  489.                 got->ios2_DstAddr[0] = (devflags & FLG_CLIENT) ? (1<<7) :  0    ;
  490.                 got->ios2_DataLength = receiveframe.size - 6;
  491.                 ReplyMsg( got );
  492.                 
  493.                 /* und 'raus */
  494.                 got=0;
  495.                 break;
  496.             }
  497.         }
  498.     }
  499.     else
  500.     {
  501.         /* CRC ERROR! */
  502.  
  503.         /* Clients Bescheid sagen, daß Müll ankam */
  504.         DoEvent( S2EVENT_ERROR | S2EVENT_RX );
  505.         
  506.         got = 0;
  507.         devstats.BadData++;
  508.     }
  509.     
  510.     if( got )
  511.     {
  512.         /* Hm... wir haben ein Packet bekommen, das keiner haben will... */
  513.         devstats.UnknownTypesReceived++;
  514.         
  515.         /* ...aber vielleicht ist da ja jemand, der genau solche Packets auffängt: */
  516.         if( ro = (struct IOSana2Req *) RemHead( &readorphanlist ) )
  517.         {
  518.             /* Packet komplett kopieren */
  519.             bufferror = ((struct BufRoutines *) ro->ios2_BufferManagement)
  520.                 -> CopyToBuff( ro->ios2_Data, &receiveframe.pkt, receiveframe.size - 2 );
  521.             
  522.             /* Fehler? */
  523.             if( !bufferror )
  524.             {
  525.                 ro->ios2_Error     = S2ERR_SOFTWARE;
  526.                 ro->ios2_WireError = S2WERR_BUFF_ERROR;
  527.             }
  528.             else
  529.             {
  530.                 ro->ios2_Error = ro->ios2_WireError = 0;
  531.             }
  532.             
  533.             /* Request befriedigen */
  534.             ro->ios2_Flags      = 0;
  535.             ro->ios2_SrcAddr[0] = (devflags & FLG_CLIENT) ?  0     : (1<<7);
  536.             ro->ios2_DstAddr[0] = (devflags & FLG_CLIENT) ? (1<<7) :  0    ;
  537.             ro->ios2_DataLength = receiveframe.size - 2;
  538.             ReplyMsg( ro );
  539.         }
  540.  
  541.         /* Noe, also entsorgen */
  542.         dotracktype( pkttyp, 0, 0, 0, 0, 1 );
  543.  
  544.     }
  545.     
  546. }
  547.  
  548. /***********************************************************
  549.  * READARGS - reads ENV:PLIP
  550.  */
  551.  
  552. static void __saveds readargs( void )
  553. {
  554.     struct RDArgs *rda;
  555.     struct args {
  556.         ULONG *timeout;
  557.         LONG *priority;
  558.         ULONG *mtu;
  559.         ULONG *bps;
  560.         ULONG *retries;
  561.     } args = { 0 };
  562.     BPTR plipvar = Open( "ENV:SANA2/PLIP.config", MODE_OLDFILE );
  563.     BPTR oldinput, infowin, oldoutput;
  564.  
  565.     infowin = Open( "con://320/128/PLIP V38.11/NOSIZE/INACTIVE", MODE_NEWFILE );
  566.     
  567.     if( infowin )
  568.     {
  569.         FPrintf( infowin,
  570.             "\x1b[0 p\n"
  571.             "\x1b[1mPLIP V38.11\x1b[0m (" __DATE__ " " __TIME__ ")\n"
  572.             "by \x1b[3mOliver Wagner\x1b[0m & \x1b[3mMichael Balzer\x1b[0m\n"
  573.             "Freeware -- see manual!\n\n" );
  574.     }
  575.  
  576.     if( !plipvar )
  577.         goto xit;
  578.  
  579.     oldinput = SelectInput( plipvar );
  580.     
  581.     rda = ReadArgs( "TIMEOUT/K/N,PRIORITY=PRI/K/N,MTU/K/N,BPS/K/N,RETRIES/K/N" , (LONG *)&args, NULL );
  582.     
  583.     if(rda)
  584.     {
  585.         if(args.timeout)
  586.         {
  587.             settimeout( *args.timeout );
  588.             if( infowin ) FPrintf(infowin, " Timeout.: %lx/%ld\n", *args.timeout, *args.timeout);
  589.         }
  590.         if(args.priority)
  591.         {
  592.             SetTaskPri( FindTask(SERVER_TASK), *args.priority);
  593.             if( infowin ) FPrintf(infowin, " Priority: %ld\n", *args.priority);
  594.         }
  595.         if( args.mtu )
  596.         {
  597.             if( *args.mtu <= PLIP_MTU )
  598.             {
  599.                 plip_mtu = *args.mtu;
  600.                 if( infowin ) FPrintf(infowin, " MTU: %ld\n", *args.mtu);
  601.             }
  602.         }
  603.         if( args.bps )
  604.         {
  605.             plip_bps = *args.bps;
  606.             if( infowin ) FPrintf(infowin, " BPS: %ld\n", *args.bps);
  607.         }
  608.         if( args.retries )
  609.         {
  610.             if( *args.retries <= 127 )
  611.             {
  612.                 plip_retries = *args.retries;
  613.                 if( infowin ) FPrintf(infowin, " Max Retries: %ld\n", *args.retries);
  614.             }
  615.         }
  616.         FreeArgs( rda );
  617.     }
  618.     else if(infowin)
  619.     {
  620.         oldoutput = SelectOutput( infowin );
  621.         PrintFault( IoErr(), "\x07 PLIP");
  622.         SelectOutput( oldoutput );
  623.     }
  624.  
  625.     Close( SelectInput( oldinput ));
  626.  
  627. xit:
  628.     /* Wake up Main server */
  629.     Signal( intdata.sigtask, SIGBREAKF_CTRL_E );
  630.  
  631.     if( infowin )
  632.     {
  633.         Delay( 10*50 );
  634.         Close( infowin );
  635.     }
  636.  
  637. }
  638.  
  639.  
  640.  
  641. /***********************************************************
  642.  * MAINLOOP - Device Dispatcher
  643.  */
  644.  
  645. static void __saveds servertask( void )
  646. {
  647.     long portsig, s, timersig;
  648.     struct IOSana2Req *currentwrite = 0, *got, *nextwrite;
  649.     long timerqueued = 0, readstart = 0x42, bufferror;
  650.  
  651.     /*
  652.      * Setup
  653.      */
  654.     
  655.     s = AllocSignal( -1 );
  656.     intdata.recsig = 1L << s;
  657.     
  658.     serverport = CreateMsgPort();
  659.     timerport  = CreateMsgPort();
  660.     portsig  = 1 << serverport->mp_SigBit;
  661.     timersig = 1 << timerport->mp_SigBit;
  662.     
  663.     NewList( &readlist );    
  664.     NewList( &writelist );
  665.     NewList( &eventlist );
  666.     NewList( &readorphanlist );
  667.     NewList( &tracklist );
  668.     
  669.     InitSemaphore( &eventlistsem );
  670.     InitSemaphore( &writelistsem );
  671.     InitSemaphore( &tracklistsem );
  672.     
  673.     treq.tr_node.io_Message.mn_ReplyPort = timerport;
  674.     OpenDevice( "timer.device", UNIT_VBLANK, &treq, 0 );
  675.     TimerBase = (struct Library *) treq.tr_node.io_Device;
  676.     GetSysTime( &devstats.LastStart );
  677.  
  678.     CreateNewProcTags(
  679.         NP_Entry, readargs,
  680.         NP_Name, "PLIP Arg Parser Process",
  681.         NP_Priority, 5,
  682.         NP_WindowPtr, -1,
  683.         TAG_DONE
  684.     );
  685.  
  686.     /* Wait for reply from Arg Parser */
  687.     Wait( SIGBREAKF_CTRL_E );
  688.  
  689.     for(;;)
  690.     {
  691.  
  692.         /* Wir lassen uns regelmäßig vom timer.device aufwecken, damit
  693.          * keine Senderequests liegen bleiben, wenn wir nicht sofort
  694.          * die Leitung bekommen können
  695.          */
  696.         if( !timerqueued )
  697.         {
  698.             treq.tr_time.tv_secs    = 2 + (devflags & FLG_CLIENT);
  699.             treq.tr_time.tv_micro   = 0;
  700.             treq.tr_node.io_Command = TR_ADDREQUEST;
  701.             SendIO( &treq );
  702.             timerqueued = 1;
  703.         }
  704.         
  705.         s = Wait( intdata.recsig | portsig | timersig );
  706.  
  707.         if( s & intdata.recsig )
  708.         {
  709.             /* Interrupt: Packet empfangen */
  710.             procread();
  711.         }
  712.         
  713.         if( s & timersig )
  714.         {
  715.             /* Aufwecksignal */
  716.             AbortIO( &treq );
  717.             WaitIO( &treq );
  718.             timerqueued = 0;
  719.         }
  720.         
  721.         if( s & portsig )
  722.         {
  723.             /* Kommandos (Requests) entgegennehmen */
  724.             
  725.             while( got = (struct IOSana2Req *) GetMsg( serverport ) )
  726.             {
  727.  
  728.                 if( got->ios2_Req.io_Command == CMD_READ )
  729.                     AddTail( &readlist, got );
  730.                 else if( got->ios2_Req.io_Command == S2_READORPHAN )
  731.                     AddTail( &readorphanlist, got );
  732.                 else
  733.                 {
  734.                     ObtainSemaphore( &writelistsem );
  735.                     AddTail( &writelist, got );
  736.                     ReleaseSemaphore( &writelistsem );
  737.                 }
  738.             }
  739.         }
  740.  
  741.         /*
  742.          * So, Signale alle erledigt; haben wir 'was zu schreiben?
  743.          */
  744.         
  745.         ObtainSemaphore( &writelistsem );
  746.         
  747.         for( currentwrite = (struct IOSana2Req *) writelist.lh_Head;
  748.              nextwrite = (struct IOSana2Req *) currentwrite->ios2_Req.io_Message.mn_Node.ln_Succ;
  749.              currentwrite = nextwrite )
  750.         {
  751.  
  752.             /* Inzwischen ein Read-Interrupt? */
  753.             if( SetSignal(0,0) & intdata.recsig) break;
  754.  
  755.             /* Arbitration */
  756.             if( devflags & FLG_CLIENT )
  757.             {
  758.                 /* Leitung frei? */
  759.                 if( !testbusy() )
  760.                     break;        /* später nochmal versuchen */
  761.                 
  762.                 /* Sende-Status setzen */
  763.                 setpout( 1 );
  764.                 
  765.                 /* Leitung immer noch frei? */
  766.                 if( !testbusy() )
  767.                 {
  768.                     setpout( 0 );
  769.                     break;        /* später nochmal versuchen */
  770.                 }
  771.             }
  772.             else
  773.             {
  774.                 /* Leitung frei? */
  775.                 if( testpout() )
  776.                     break;        /* später nochmal versuchen */
  777.                 
  778.                 /* Sende-Status setzen */
  779.                 setbusy( 0 );
  780.                 
  781.                 /* Leitung immer noch frei? */
  782.                 if( testpout() )
  783.                 {
  784.                     /*setbusy( 1 );*/
  785.                     break;        /* später nochmal versuchen */
  786.                 }
  787.             }
  788.             
  789.             /* Gut, wir können beginnen zu senden */
  790.             
  791.             /* Daten kopieren */
  792.             bufferror = ((struct BufRoutines *) currentwrite->ios2_BufferManagement)
  793.                 -> CopyFromBuff( sendframe.data, currentwrite->ios2_Data, currentwrite->ios2_DataLength );
  794.             
  795.             /* Fehler? */
  796.             if( !bufferror )
  797.             {
  798.                 currentwrite->ios2_Error     = S2ERR_SOFTWARE;
  799.                 currentwrite->ios2_WireError = S2WERR_BUFF_ERROR;
  800.                 Remove( currentwrite );
  801.                 ReplyMsg( currentwrite );
  802.                 continue;
  803.                 /* weiter mit nächstem Write-Req */
  804.             }
  805.             
  806.             /* Packet-Header füllen */
  807.             sendframe.sync = 0x42424242;
  808.             sendframe.pkt  = currentwrite->ios2_PacketType;
  809.             sendframe.size = currentwrite->ios2_DataLength + 6;
  810.             
  811.             /* CRC berechnen und einsetzen */
  812.             {
  813.                 int l = currentwrite->ios2_DataLength;
  814.                 unsigned char *d = sendframe.data;
  815.                 unsigned short crc = 0;
  816.  
  817.                 crc = CRC16( d, l );
  818.  
  819.                 sendframe.crc = crc;
  820.             }
  821.             
  822.             /* Packet Senden */
  823.  
  824.             readstart = procwrite( (char *) &sendframe, sendframe.size + 6 );
  825.  
  826.             if( !readstart )
  827.             {
  828.                 /* Packet erfolgreich gesendet */
  829.                 dotracktype( sendframe.pkt, 1, 0, currentwrite->ios2_DataLength, 0, 0 );
  830.                 currentwrite->ios2_Error = currentwrite->ios2_WireError = 0;
  831.                 Remove( currentwrite );
  832.                 ReplyMsg( currentwrite );
  833.             }
  834.             else
  835.             {
  836.                 /* Fehler; WriteRetryCounter erhöhen */
  837.                 if( ( currentwrite->ios2_Error++ ) > plip_retries )
  838.                 {
  839.                     /* Maximale Fehleranzahl erreicht */
  840.                     currentwrite->ios2_Error         = S2ERR_BAD_STATE;
  841.                     currentwrite->ios2_WireError    = S2WERR_GENERIC_ERROR;
  842.                     Remove( currentwrite );
  843.                     ReplyMsg( currentwrite );
  844.                 }
  845.                 break;
  846.             }
  847.         }
  848.         
  849.         ReleaseSemaphore( &writelistsem );
  850.         
  851.         /* Alle Signale bearbeitet */
  852.     }
  853. }
  854.  
  855.  
  856. /************************************************************
  857.  * DEVICE-Management und -Support
  858.  */
  859.  
  860. long __asm __saveds DevOpen( register __a1 struct IOSana2Req *ior,
  861.     register __d0 long unit, register __d1 long flags,
  862.     register __a6 struct MyDev *devnode )
  863. {
  864.     struct TagItem *ti;
  865.     struct BufRoutines *br;
  866.  
  867.     devnode->l.lib_OpenCnt++;    /* Expunge-Schutz */
  868.  
  869.     if( unit < 0 || unit > 1 )
  870.     {
  871.         devnode->l.lib_OpenCnt--;
  872.         ior->ios2_Req.io_Error  = -1;
  873.         ior->ios2_Req.io_Device = (struct Device *) -1;
  874.         return( -1 );
  875.         /* openfailed */ 
  876.     }
  877.  
  878.     /* already open? */
  879.     if( devnode->l.lib_OpenCnt > 1 )
  880.     {
  881.         if( (unit && !(devflags & FLG_CLIENT)) ||
  882.             (flags & SANA2OPF_MINE) )
  883.         {
  884.             /* busy/open */
  885.             devnode->l.lib_OpenCnt--;
  886.             ior->ios2_Req.io_Error  = -1;
  887.             ior->ios2_Req.io_Device = (struct Device *) -1;
  888.             return( -1 );
  889.         }
  890.     }
  891.     
  892.     if( flags & SANA2OPF_MINE )
  893.         devflags     |= FLG_EXCLUSIVE;
  894.     
  895.     if( unit )
  896.     {
  897.         devflags     |= FLG_CLIENT;
  898.         intdata.mode |= IM_CLIENT;
  899.     }
  900.  
  901.     intdata.SysBase=SysBase; /* Clone SysBase */
  902.  
  903.     /* Start Server Process */
  904.     if( !intdata.sigtask ) 
  905.         intdata.sigtask = CreateTask( SERVER_TASK, 15, servertask, 4000);
  906.     
  907.     if( !intdata.sigtask )
  908.     {
  909.         /* kein Task */
  910.         devnode->l.lib_OpenCnt--; 
  911.         ior->ios2_Req.io_Error  = -1;
  912.         ior->ios2_Req.io_Device = (struct Device *) -1;
  913.         return( -1 );
  914.     }
  915.  
  916.     /* Task Setup Done; convert Taglist */
  917.     br = AllocMem( 8, MEMF_CLEAR );
  918.     
  919.     if( ti = FindTagItem(S2_CopyToBuff, ior->ios2_BufferManagement) )
  920.         br->CopyToBuff = ti->ti_Data;
  921.     
  922.     if( ti = FindTagItem(S2_CopyFromBuff, ior->ios2_BufferManagement) )
  923.         br->CopyFromBuff = ti->ti_Data;
  924.  
  925.     if( !br->CopyToBuff || !br->CopyFromBuff )
  926.     {
  927.         FreeMem( br, 8 );
  928.         devnode->l.lib_OpenCnt--; 
  929.         ior->ios2_Req.io_Error  = -1;
  930.         ior->ios2_Req.io_Device = (struct Device *) -1;
  931.         return( -1 );
  932.     }
  933.     
  934.     devnode->l.lib_Flags &= ~LIBF_DELEXP;
  935.     
  936.     ior->ios2_BufferManagement = br;
  937.     ior->ios2_Req.io_Unit = (struct Unit *) br;
  938.     ior->ios2_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  939.     ior->ios2_Req.io_Error = 0;
  940.     return( 0 );
  941. }
  942.  
  943.  
  944. static long goonline( void )
  945. {
  946.     long x;
  947.  
  948.     if( ISOFFLINE )
  949.     {
  950.         if( x = setupint() )
  951.             return( -1 );
  952.         
  953.         devflags &= ~(FLG_OFFLINE | FLG_NOTCONFIGURED);
  954.     }
  955.  
  956.     return( 0 );    
  957. }
  958.  
  959.  
  960. static void gooffline( void )
  961. {
  962.     if( ! (ISOFFLINE) )
  963.     {
  964.         cleanupint();
  965.         devflags |= FLG_OFFLINE;
  966.     }
  967. }
  968.  
  969.  
  970. long __asm __saveds DevExpunge( register __a6 struct MyDev *devnode )
  971. {
  972.     long seglist;
  973.     struct trackrec *trackrec;
  974.  
  975.     if( devnode->l.lib_OpenCnt )
  976.     {
  977.         devnode->l.lib_Flags |= LIBF_DELEXP;
  978.         return( 0 );
  979.     }
  980.     
  981.     gooffline();
  982.     
  983.     if( intdata.sigtask ) RemTask( intdata.sigtask );
  984.     
  985.     if( serverport ) FreeMem( serverport, sizeof(struct MsgPort) );
  986.     if( timerport  ) FreeMem( timerport,  sizeof(struct MsgPort) );
  987.     
  988.     Remove( devnode );
  989.     seglist = (long) devnode->seglist;
  990.     FreeMem( ((char *) devnode) - devnode->l.lib_NegSize,
  991.         devnode->l.lib_PosSize + devnode->l.lib_NegSize );
  992.  
  993.     /* Free tracktype records */
  994.     while( ( trackrec = ( struct trackrec * ) RemHead( &tracklist ) ) )
  995.         FreeMem( trackrec, sizeof( *trackrec ) );
  996.     
  997.     return( seglist );
  998. }
  999.  
  1000.  
  1001. long __asm __saveds DevClose( register __a1 struct IOSana2Req *ior,
  1002.     register __a6 struct MyDev *devnode )
  1003. {
  1004.     FreeMem( ior->ios2_Req.io_Unit, 8 );
  1005.     
  1006.     ior->ios2_Req.io_Device = (struct Device *) -1;
  1007.     ior->ios2_Req.io_Unit   = (struct Unit   *) -1;
  1008.  
  1009.     if( !(--devnode->l.lib_OpenCnt) ) /* ERROR! */
  1010.     {
  1011.         devflags &= ~FLG_EXCLUSIVE;
  1012.         if( devnode->l.lib_Flags & LIBF_DELEXP )
  1013.             return( DevExpunge(devnode) );
  1014.     }
  1015.     
  1016.     return( 0 );
  1017. }
  1018.  
  1019.  
  1020. void __saveds __asm DevBeginIO( register __a1 struct IOSana2Req *ior )
  1021. {
  1022.     struct Sana2DeviceQuery *devquery;
  1023.  
  1024.     ior->ios2_Error = IOERR_NOCMD;
  1025.     
  1026.     switch( ior->ios2_Req.io_Command )
  1027.     {
  1028.         case S2_GETSTATIONADDRESS:
  1029.             ior->ios2_SrcAddr[0] = ior->ios2_DstAddr[0] = (devflags & FLG_CLIENT) ? 1<<7 : 0;
  1030.             ior->ios2_Error = ior->ios2_WireError = 0;
  1031.             break;
  1032.  
  1033.         case S2_TRACKTYPE:
  1034.             if( addtracktype( ior->ios2_PacketType ) )
  1035.             {
  1036.                 ior->ios2_Error = S2ERR_BAD_STATE;
  1037.                 ior->ios2_WireError = S2WERR_ALREADY_TRACKED;
  1038.             }
  1039.             else
  1040.                 ior->ios2_Error = ior->ios2_WireError = 0;
  1041.             break;
  1042.  
  1043.         case S2_UNTRACKTYPE:
  1044.             if( remtracktype( ior->ios2_PacketType ) )
  1045.             {
  1046.                 ior->ios2_Error = S2ERR_BAD_STATE;
  1047.                 ior->ios2_WireError = S2WERR_NOT_TRACKED;
  1048.             }
  1049.             else
  1050.                 ior->ios2_Error = ior->ios2_WireError = 0;
  1051.             break;
  1052.  
  1053.  
  1054.         case S2_GETTYPESTATS:
  1055.             if( gettrackrec( ior->ios2_PacketType, ior->ios2_StatData ) )
  1056.             {
  1057.                 ior->ios2_Error = S2ERR_BAD_STATE;
  1058.                 ior->ios2_WireError = S2WERR_NOT_TRACKED;
  1059.             }
  1060.             else
  1061.                 ior->ios2_Error = ior->ios2_WireError = 0;
  1062.             break;
  1063.  
  1064.         case S2_GETGLOBALSTATS:
  1065.             memcpy( ior->ios2_StatData, &devstats, sizeof(struct Sana2DeviceStats) );
  1066.             ior->ios2_Error = ior->ios2_WireError = 0;
  1067.             break;
  1068.             
  1069.         case S2_DEVICEQUERY:
  1070.             ior->ios2_Error = ior->ios2_WireError = 0;
  1071.             devquery = ior->ios2_StatData;
  1072.             devquery->DevQueryFormat = devquery->DeviceLevel = 0;
  1073.             
  1074.             if( devquery->SizeAvailable >  3 ) devquery->AddrFieldSize = 1;
  1075.             if( devquery->SizeAvailable >  5 ) devquery->MTU           = plip_mtu;
  1076.             if( devquery->SizeAvailable >  9 ) devquery->BPS           = plip_bps;
  1077.             if( devquery->SizeAvailable > 13 ) devquery->HardwareType  = PLIP_HWTYPE;
  1078.             
  1079.             devquery->SizeSupplied = min( devquery->SizeAvailable, 18 );
  1080.             break;
  1081.             
  1082.         case S2_ONLINE:
  1083.             if( goonline() )
  1084.                 ior->ios2_Error = S2ERR_NO_RESOURCES;
  1085.             else
  1086.                 ior->ios2_Error = ior->ios2_WireError = 0;
  1087.             break;
  1088.             
  1089.         case S2_OFFLINE:
  1090.             gooffline();
  1091.             ior->ios2_Error = ior->ios2_WireError = 0;
  1092.             break;
  1093.  
  1094.         case S2_ONEVENT:
  1095.             ObtainSemaphore( &eventlistsem );
  1096.             AddTail( &eventlist, ior );
  1097.             ReleaseSemaphore( &eventlistsem );
  1098.             return;
  1099.  
  1100.         case CMD_READ:
  1101.         case S2_READORPHAN:
  1102.             if( ISOFFLINE )
  1103.             {
  1104.                 ior->ios2_Error     = S2ERR_OUTOFSERVICE;
  1105.                 ior->ios2_WireError = S2WERR_UNIT_OFFLINE;
  1106.                 break;
  1107.             }
  1108.             
  1109.             PutMsg( serverport, ior );
  1110.             return;
  1111.             
  1112.         case CMD_WRITE:
  1113.         case S2_BROADCAST:
  1114.             if( ISOFFLINE )
  1115.             {
  1116.                 ior->ios2_Error     = S2ERR_OUTOFSERVICE;
  1117.                 ior->ios2_WireError = S2WERR_UNIT_OFFLINE;
  1118.                 break;
  1119.             }
  1120.             
  1121.             if( ior->ios2_DataLength > plip_mtu )
  1122.             {
  1123.                 ior->ios2_Error     = S2ERR_MTU_EXCEEDED;
  1124.                 ior->ios2_WireError = 0;
  1125.                 break;
  1126.             }
  1127.  
  1128.             /* 38.10: ios2_Error wird als WriteRetryCounter benutzt */
  1129.  
  1130.             ior->ios2_Error = 0;
  1131.             
  1132.             PutMsg( serverport, ior );
  1133.             return;
  1134.             
  1135.         case S2_CONFIGINTERFACE:
  1136.             if( devflags & FLG_NOTCONFIGURED )
  1137.             {
  1138.                 ior->ios2_SrcAddr[0] = (devflags & FLG_CLIENT) ? (1<<7) : 0;
  1139.                 
  1140.                 if( goonline() )
  1141.                 {
  1142.                     ior->ios2_Error     = S2ERR_NO_RESOURCES;
  1143.                     ior->ios2_WireError = 0;
  1144.                 }
  1145.                 else
  1146.                 {
  1147.                     ior->ios2_Error = ior->ios2_WireError = 0;
  1148.                 }
  1149.                 
  1150.                 break;
  1151.             }
  1152.             
  1153.             ior->ios2_Error     = S2ERR_SOFTWARE;
  1154.             ior->ios2_WireError = S2WERR_IS_CONFIGURED;
  1155.             break;
  1156.     }
  1157.  
  1158.     ior->ios2_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  1159.     return;
  1160. }
  1161.  
  1162.  
  1163. static long isinlist( struct Node *n, struct List *l )
  1164. {
  1165.     struct Node *cmp = l->lh_Head;
  1166.  
  1167.     while( cmp != n && cmp->ln_Succ )
  1168.         cmp = cmp->ln_Succ;
  1169.     
  1170.     return( cmp == n );
  1171. }
  1172.  
  1173.  
  1174. long __asm __saveds DevAbortIO( register __a1 struct IOSana2Req *ior )
  1175. {
  1176.     Forbid();
  1177.     
  1178.     if( isinlist(ior, &eventlist) ||
  1179.         isinlist(ior, &readlist)  ||
  1180.         isinlist(ior, &readorphanlist) )
  1181.     {
  1182.         Remove( ior );
  1183.         ior->ios2_Error     = IOERR_ABORTED;
  1184.         ior->ios2_WireError = 0;
  1185.         ReplyMsg( ior );
  1186.         Permit();
  1187.         return( 0 );
  1188.     }
  1189.     else
  1190.     {
  1191.         ObtainSemaphore( &writelistsem );
  1192.         
  1193.         if( isinlist(ior, &writelist) )
  1194.         {
  1195.             Remove( ior );
  1196.             ReleaseSemaphore( &writelistsem );
  1197.             
  1198.             ior->ios2_Error     = IOERR_ABORTED;
  1199.             ior->ios2_WireError = 0;
  1200.             
  1201.             ReplyMsg( ior );
  1202.             Permit();
  1203.             return( 0 );
  1204.         }
  1205.         
  1206.         ReleaseSemaphore( &writelistsem );
  1207.     }
  1208.     
  1209.     Permit();
  1210.     
  1211.     return( -1 );
  1212. }
  1213.  
  1214. /* EOF */
  1215.