home *** CD-ROM | disk | FTP | other *** search
/ ftp.urbanrage.com / 2015-02-07.ftp.urbanrage.com.tar / ftp.urbanrage.com / pub / pearpc / pearpc-verbose15-rtl8139.patch < prev    next >
Text File  |  2004-05-24  |  10KB  |  348 lines
  1. diff -urN pearpc/src/io/rtl8139/rtl8139.cc pearpc-verbose15/src/io/rtl8139/rtl8139.cc
  2. --- pearpc/src/io/rtl8139/rtl8139.cc    2004-05-25 04:15:59.000000000 -0500
  3. +++ pearpc-verbose15/src/io/rtl8139/rtl8139.cc    2004-05-25 17:39:46.000000000 -0500
  4. @@ -30,7 +30,6 @@
  5.  #include <cstring>
  6.  #include <unistd.h>
  7.  
  8. -#include "system/sys.h"
  9.  #include "system/systhread.h"
  10.  #include "cpu_generic/ppc_cpu.h"
  11.  #include "cpu_generic/ppc_mmu.h"
  12. @@ -50,7 +49,7 @@
  13.  
  14.  
  15.  enum RxHeaderBits {
  16. -    Rx_ROK =  1<<0, // receive okay
  17. +    Rx_ROK =  1<<0, // recieve okay
  18.      Rx_FAE =  1<<1, // frame alignment error
  19.      Rx_CRC =  1<<2, // crc error
  20.      Rx_LONG = 1<<3, // packet > 4k
  21. @@ -133,6 +132,7 @@
  22.  };
  23.  
  24.  struct Packet {
  25. +    uint32  pid;
  26.      uint16    size;
  27.      byte    packet[MAX_PACKET_SIZE];
  28.  };
  29. @@ -205,12 +205,6 @@
  30.      bool        mEEPROMWritable;
  31.      Registers    mRegisters;
  32.      uint16        mIntStatus;
  33. -    bool        mRxEnabled;
  34. -    bool        mTxEnabled;
  35. -    bool        mUpStalled;
  36. -    bool        mDnStalled;
  37. -    byte        mRxPacket[MAX_PACKET_SIZE];
  38. -    uint        mRxPacketSize;
  39.      int        mRingBufferSize;
  40.      bool         mGoodBSA;
  41.      enet_iface_t    mENetIf;
  42. @@ -218,6 +212,11 @@
  43.      int        mVerbose;
  44.      byte        mHead;
  45.      byte        mTail;
  46. +    byte        mActive;
  47. +    byte        mWatermark;
  48. +    byte            mLast;
  49. +    byte            mLastPackets[2];
  50. +    uint32        mPid;
  51.      Packet        mPackets[MAX_PACKETS];
  52.  
  53.  
  54. @@ -263,12 +262,11 @@
  55.      mRingBufferSize = 8192;
  56.      mHead = 0;
  57.      mTail = 0;
  58. +    mActive = 0;
  59. +    mWatermark = 0;
  60. +    mLastPackets[0] = 0;
  61. +    mLastPackets[1] = 0;
  62.      mGoodBSA = false;
  63. -    mRxEnabled = false;
  64. -    mTxEnabled = false;
  65. -    mUpStalled = false;
  66. -    mDnStalled = false;
  67. -    mRxPacketSize = 0;
  68.      // EEPROM config (FIXME: endianess)
  69.  
  70.      // set up mac address
  71. @@ -323,7 +321,7 @@
  72.      }
  73.      if (cr & 0x08) {
  74.          mRegisters.CommandRegister |= 0x08;
  75. -        // enable receiver
  76. +        // enable reciever
  77.      }
  78.      if (cr & 0x04) {
  79.          mRegisters.CommandRegister |= 0x04;
  80. @@ -399,6 +397,7 @@
  81.      int e;
  82.      if ((e = sys_create_mutex(&mLock))) throw IOException(e);
  83.      mENetIf = aENetIf;
  84. +    mPid = 0;
  85.      PCIReset();
  86.      totalReset();
  87.  }
  88. @@ -407,24 +406,41 @@
  89.  {
  90.      byte*        addr;
  91.      byte*           base;
  92. +    bool        good;
  93.  
  94. +    if (mTail == mHead) {
  95. +        return;
  96. +    }
  97.      if (ppc_direct_physical_memory_handle(mRegisters.RxBufferStartAddr, base) == PPC_MMU_OK) {
  98.          addr = base + mRegisters.CBA;
  99. +        if (mRegisters.CBA > mRingBufferSize) {// sending outside, could cause problems?
  100. +            good = false;
  101. +        } else {
  102. +            good = true;
  103. +        }
  104. +#if 0
  105.          if ((mRegisters.CBA) > mRingBufferSize) {
  106. -            if (mVerbose) IO_RTL8139_TRACE("client ring buffer wrap around [%d]\n", raiseIntr);
  107. +            IO_RTL8139_TRACE("client ring buffer wrap around [%d]\n", raiseIntr);
  108.              addr = base;
  109.              mRegisters.CBA = 0;
  110.              mRegisters.CAPR = 0xfff0;
  111.  //            mRegisters.CommandRegister |= 1;
  112.              return;
  113.          }
  114. +#endif
  115.          memcpy(addr, mPackets[mTail].packet, mPackets[mTail].size);
  116.          if (mVerbose) IO_RTL8139_TRACE("wrote %04x bytes to the ring buffer\n", mPackets[mTail].size);
  117.          mRegisters.EarlyRxByteCount = mPackets[mTail].size;
  118.          mRegisters.EarlyRxStatus = 8;
  119.          mRegisters.CBA += mPackets[mTail].size;
  120.          mRegisters.CommandRegister &= 0xfe; // RxBuffer has data
  121. -        mTail = (mTail+1) % MAX_PACKETS;
  122. +        mLastPackets[1] = mLastPackets[0];
  123. +        mLastPackets[0] = mTail;
  124. +        mActive--;
  125. +        IO_RTL8139_TRACE("Outgoing - Addr: %08x, Pid: %08x, Size: %04x\n", addr, mPackets[mTail].pid, mPackets[mTail].size-4);
  126. +        if (good) {
  127. +            mTail = (mTail+1) % MAX_PACKETS;
  128. +        }
  129.          if (raiseIntr) {
  130.              mIntStatus |= 1;
  131.              maybeRaiseIntr();
  132. @@ -470,7 +486,10 @@
  133.  {
  134.      if (r != 0) return false;
  135.      bool retval = false;
  136. +//    IO_RTL8139_TRACE("readDevice waiting for mLock\n");
  137.      sys_lock_mutex(mLock);
  138. +//    IO_RTL8139_TRACE("readDevice has mLock\n");
  139. +
  140.      if (port == 0x3e) {
  141.          // IntStatus (no matter which window)
  142.          if (size != 2) {
  143. @@ -493,6 +512,13 @@
  144.              if (mVerbose) IO_RTL8139_TRACE("read Command Register = %02x\n", data);
  145.              break;
  146.          }
  147. +        case 0x64: {
  148. +            if (mVerbose) IO_RTL8139_TRACE("read Basic Mode Status = %04x\n", data);
  149. +            if ((mTail != mHead) && (mRegisters.CommandRegister & 0x01)) {
  150. +                transferPacket(true);
  151. +            }
  152. +            break;
  153. +        }
  154.          default:
  155.              if (mVerbose) IO_RTL8139_TRACE("read reg %04x (size %d) = %08x\n", port, size, data);
  156.              break;
  157. @@ -501,6 +527,7 @@
  158.          retval = true;
  159.      }
  160.      sys_unlock_mutex(mLock);
  161. +//    IO_RTL8139_TRACE("readDevice freed mLock\n");
  162.      return retval;
  163.  }
  164.  
  165. @@ -510,7 +537,9 @@
  166.  
  167.      if (r != 0) return false;
  168.      bool retval = false;
  169. +//    IO_RTL8139_TRACE("writeDevice waiting for mLock\n");
  170.      sys_lock_mutex(mLock);
  171. +//    IO_RTL8139_TRACE("writeDevice has mLock\n");
  172.      original = data;
  173.      data = swapData(data, size);
  174.      if (port == 0x37) {
  175. @@ -582,21 +611,26 @@
  176.              mRegisters.CAPR = 0xfff0;
  177.              mRegisters.CommandRegister |= 1;
  178.              mGoodBSA = true;
  179. -            if (mTail != mHead) {
  180. -                transferPacket(true);
  181. -            }
  182. +            transferPacket(true);
  183.              break;
  184.          }
  185.          case 0x38: {
  186.              if (mVerbose) IO_RTL8139_TRACE("update to CAPR: CAPR %04x, CBA %04x\n", data, mRegisters.CBA);
  187.              mRegisters.CAPR = data;
  188. +            if (mRegisters.CAPR >= mRegisters.CBA) {
  189. +                IO_RTL8139_WARN("Bad packet read by client? Active %02x, CAPR %04x, CBA %04x, Tail %02x, Head %02x\n", mActive, mRegisters.CAPR, mRegisters.CBA, mTail, mHead);
  190. +                mRegisters.CBA = mRegisters.CAPR + 0x10;
  191. +            }
  192.              if (mRegisters.CAPR > mRingBufferSize) { //client knows about wrap, so wrap
  193. +                mRegisters.CBA = 0;
  194.                  mIntStatus |= 1; // fake send
  195.                  maybeRaiseIntr();
  196. +                IO_RTL8139_TRACE("client wrap on CAPR set Active %02x, CAPR %04x, CBA %04x, Tail %02x, Head %02x\n", mActive, mRegisters.CAPR, mRegisters.CBA, mTail, mHead);
  197.                  /*
  198. +                mIntStatus |= 1; // fake send
  199. +                maybeRaiseIntr();
  200.                  mRegisters.CAPR = 0xfff0;
  201.                  mRegisters.CommandRegister |= 1;
  202. -                mRegisters.CBA = 0;
  203.                  */
  204.              } else {
  205.                  if (mTail != mHead) {
  206. @@ -633,84 +667,85 @@
  207.          retval = true;
  208.      }
  209.      sys_unlock_mutex(mLock);
  210. +//    IO_RTL8139_TRACE("writeDevice freed mLock\n");
  211.      return retval;
  212.  }
  213.  
  214. -void handlePacket()
  215. +void handleRxQueue()
  216.  {
  217.      uint16        header;
  218.      uint16        psize;
  219. +    byte            rxPacket[MAX_PACKET_SIZE];
  220. +    uint16          rxPacketSize;
  221.      byte        tmp;
  222.      byte        broadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  223.  
  224. -    mRxPacketSize = read(mENetIf.fd, mRxPacket, sizeof mRxPacket);
  225. -    if (!mGoodBSA) {
  226. -        mRxPacketSize = 0;
  227. -    } else {
  228. +    while(1) {
  229. +        rxPacketSize = read(mENetIf.fd, rxPacket, sizeof rxPacket);
  230.          if (mVerbose) IO_RTL8139_TRACE("got packet from the world at large\n");
  231. +        if (!mGoodBSA) continue;
  232.          if (mVerbose > 1) {
  233. -            dumpMem(mRxPacket, mRxPacketSize);
  234. +            dumpMem(rxPacket, rxPacketSize);
  235.          }
  236.          header = 0;
  237. -        if (mRxPacketSize < 64) {
  238. -            for ( ; mRxPacketSize < 60; mRxPacketSize++) {
  239. -                mRxPacket[mRxPacketSize] = 0;
  240. +        if (rxPacketSize < 64) {
  241. +            for ( ; rxPacketSize < 60; rxPacketSize++) {
  242. +                rxPacket[rxPacketSize] = 0;
  243.              }
  244.              //header |= Rx_RUNT; // set runt status
  245.          }
  246.          /* pad to a 4 byte boundary */
  247. -        for (int i = 4-(mRxPacketSize % 4); i != 0; i--) {
  248. -            mRxPacket[mRxPacketSize++] = 0;
  249. -        }
  250. -        if (memcmp((byte*)&(mRxPacket[0]), (byte*)&(mRegisters.id0), 6) == 0) {
  251. -            //    if (mVerbose) IO_RTL8139_TRACE("Physical Address Match\n");
  252. -            header |= Rx_PAM;
  253. +        for (int i = 4-(rxPacketSize % 4); i != 0; i--) {
  254. +            rxPacket[rxPacketSize++] = 0;
  255.          }
  256. -        if (memcmp((byte*)&(mRxPacket[0]), broadcast, 6) == 0) {
  257. +        if (memcmp(rxPacket, broadcast, 6) == 0) {
  258.              header |= Rx_BAR;
  259.          }
  260. +//        IO_RTL8139_TRACE("handleRxQueue waiting for mLock\n");
  261. +        sys_lock_mutex(mLock);
  262. +//        IO_RTL8139_TRACE("handleRxQueue has mLock\n");
  263. +        if (memcmp(rxPacket, (byte*)&(mRegisters.id0), 6) == 0) {
  264. +            if (mVerbose > 1) IO_RTL8139_TRACE("Physical Address Match\n");
  265. +            header |= Rx_PAM;
  266. +        }
  267.          // check crc?
  268.          header |= Rx_ROK;
  269. -        psize = mRxPacketSize;
  270. +        psize = rxPacketSize;
  271. +        IO_RTL8139_TRACE("Incoming - Pid: %08x, Header: %04x, Size: %04x\n", mPid, header, psize);
  272.          mPackets[mHead].packet[0] = header;
  273.          mPackets[mHead].packet[1] = header>>8;
  274.          mPackets[mHead].packet[2] = psize;
  275.          mPackets[mHead].packet[3] = psize>>8;
  276. -        memcpy(&(mPackets[mHead].packet[4]), mRxPacket, mRxPacketSize);
  277. -        mPackets[mHead].size = mRxPacketSize+4;
  278. +        memcpy(&(mPackets[mHead].packet[4]), rxPacket, rxPacketSize);
  279. +        mPackets[mHead].size = rxPacketSize+4;
  280. +        mPackets[mHead].pid = mPid;
  281. +        tmp = mHead;
  282.          if (mHead == mTail) { /* first recent packet buffer */
  283.              mHead = (mHead+1) % MAX_PACKETS;
  284.          } else {
  285. -            tmp = mHead;
  286.              mHead = (mHead+1) % MAX_PACKETS;
  287.              if (mHead == mTail) {
  288.                  mHead = tmp; // reset it back 
  289.                  IO_RTL8139_WARN("Internal Buffer wrapped around\n");
  290. +            } 
  291. +        }
  292. +        if (tmp != mHead) {
  293. +            mPid++;
  294. +            mActive++;
  295. +            if (mActive > mWatermark) {
  296. +                IO_RTL8139_TRACE("Watermark: %02x\n", mWatermark);
  297. +                mWatermark = mActive;
  298.              }
  299.          }
  300.          if (mRegisters.CommandRegister & 1) { /* no packets in process, kick one out */
  301. -            sys_lock_mutex(mLock);
  302.              transferPacket(true);
  303. -            sys_unlock_mutex(mLock);
  304. -        }
  305. -    }
  306. -}
  307. -
  308. -/* new */
  309. -void handleRxQueue()
  310. -{
  311. -    mRxPacketSize = 0; // no packets at the moment
  312. -    while (1) {
  313. -        if (g_sys_ethtun_pd.wait_receive(&mENetIf) == 0) {
  314. -            handlePacket();
  315. -        } else {
  316. -            // don't waste our timeslice
  317. -            sys_suspend();
  318.          }
  319. +        sys_unlock_mutex(mLock);
  320. +//        IO_RTL8139_TRACE("handleRxQueue freed mLock\n");
  321.      }
  322.  }
  323.  
  324. -};
  325. +}; // end of rtl8139 class
  326.  
  327.  static void *rtl8139HandleRxQueue(void *nic)
  328.  {
  329. @@ -724,15 +759,12 @@
  330.  #include "configparser.h"
  331.  #include "tools/strtools.h"
  332.  
  333. -#define RTL8139_KEY_INSTALLED   "pci_rtl8139_installed"
  334. -#define RTL8139_KEY_MAC         "pci_rtl8139_mac"
  335. -#define RTL8139_KEY_VERBOSE     "pci_rtl8139_verbose"
  336. +#define RTL8139_KEY_INSTALLED    "pci_rtl8139_installed"
  337. +#define RTL8139_KEY_MAC        "pci_rtl8139_mac"
  338. +#define RTL8139_KEY_VERBOSE    "pci_rtl8139_verbose"
  339.  
  340.  void rtl8139_init()
  341.  {
  342. -    String tunstr_;
  343. -    char   tun_name[1024];
  344. -
  345.      int verbose = 0;
  346.  
  347.      verbose = gConfig->getConfigInt(RTL8139_KEY_VERBOSE); 
  348.