Ignore:
Timestamp:
May 12, 2005, 6:25:29 PM (16 years ago)
Author:
Jennifer Averett <Jennifer.Averett@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
f583bb2
Parents:
f321fdc8
Message:

2005-05-12 Jennifer Averett <jennifer.averett@…>

  • README.VME, include/bsp.h, irq/irq.h, network/GT64260eth.c, pci/detect_host_bridge.c, pci/gtpcireg.h, pci/pci.c, pci/pci.h, pci/pci_interface.c, pci/pcifinddevice.c: Submitted by Kate Feng <feng1@…> as RTEMS-MVME5500 BSP v1.1 release. Modifications made to merge this release with the current tree.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/powerpc/mvme5500/network/GT64260eth.c

    rf321fdc8 r54cb48f  
    132132static void GTeth_init_rx_ring(struct GTeth_softc *sc);
    133133static void GT64260eth_daemon(void *arg);
    134 static int GT64260eth_sendpacket(struct GTeth_softc *sc,struct mbuf *m,enum GTeth_txprio);
    135 static unsigned GTeth_txq_done(struct GTeth_softc *sc, enum GTeth_txprio txprio);
    136 static void GTeth_tx_cleanup(struct GTeth_softc *sc, enum GTeth_txprio, int);
    137 static void GTeth_tx_start(struct GTeth_softc *sc, enum GTeth_txprio);
    138 static void GTeth_tx_stop(struct GTeth_softc *sc, enum GTeth_whack_op op);
    139 static void GTeth_rx_cleanup(struct GTeth_softc *sc, enum GTeth_rxprio);
    140 static int GT64260eth_rx(struct GTeth_softc *sc, enum GTeth_rxprio);
     134static int GT64260eth_sendpacket(struct GTeth_softc *sc,struct mbuf *m);
     135static unsigned GTeth_txq_done(struct GTeth_softc *sc);
     136static void GTeth_tx_cleanup(struct GTeth_softc *sc);
     137static void GTeth_tx_start(struct GTeth_softc *sc);
     138static void GTeth_tx_stop(struct GTeth_softc *sc);
     139static void GTeth_rx_cleanup(struct GTeth_softc *sc);
     140static int GT64260eth_rx(struct GTeth_softc *sc);
    141141static void GTeth_rx_setup(struct GTeth_softc *sc);
    142 static void GTeth_rxprio_setup(struct GTeth_softc *sc, enum GTeth_rxprio);
    143 static void GTeth_rx_stop(struct GTeth_softc *dc, enum GTeth_whack_op op);
     142static void GTeth_rxprio_setup(struct GTeth_softc *sc);
     143static void GTeth_rx_stop(struct GTeth_softc *dc);
    144144static void GT64260eth_isr();
    145145static int GTeth_hash_compute(struct GTeth_softc *sc,unsigned char eaddr[ETHER_ADDR_LEN]);
     
    151151
    152152static struct GTeth_softc *root_GT64260eth_dev = NULL;
    153 static int GTeth_MissedFrame_err=0; 
    154153
    155154static void GT64260eth_irq_on(const rtems_irq_connect_data *irq)
     
    161160    outl(0x30883444,ETH0_EIMR); /* MOTLoad default interrupt mask */
    162161    return;
    163   }
     162  } 
    164163}
    165164
     
    187186  outl( ~cause,ETH0_EICR);  /* clear the ICR */
    188187
    189   if (cause & (ETH_IR_RxBuffer_3|ETH_IR_RxError_3)) {
     188  /* ETH_IR_RxBuffer_3|ETH_IR_RxError_3 */
     189  if (cause & 0x880000) {
    190190     sc->stats.rxInterrupts++;
    191191     events |= RX_EVENT;
    192192  }
    193193  /* If there is an error, we want to continue to next descriptor */
    194   if (cause & (ETH_IR_TxBufferHigh|ETH_IR_TxEndHigh|ETH_IR_TxErrorHigh)) {
     194  /* ETH_IR_TxBufferHigh|ETH_IR_TxEndHigh|ETH_IR_TxErrorHigh */
     195  if (cause & 0x444) {
    195196       sc->stats.txInterrupts++;
    196197       events |= TX_EVENT;
    197        if ((sc->txq_nactive) && ((inl(ETH0_ESDCMR)&ETH_ESDCMR_TXDH)==0))
    198           outl(ETH_ESDCMR_TXDH | ETH_ESDCMR_ERD,ETH0_ESDCMR);
    199   }
     198       /* It seems to be unnecessary. However, it's there
     199        * to be on the safe side due to the datasheet.
     200        * So far, it does not seem to affect the network performance
     201        * based on the EPICS catime.
     202        */
     203       /* ETH_ESDCMR_TXDH | ETH_ESDCMR_ERD = 0x800080 */
     204       if ((sc->txq_nactive > 1)&& ((inl(ETH0_ESDCMR)&ETH_ESDCMR_TXDH)==0))
     205          outl(0x800080,ETH0_ESDCMR);
     206
     207
     208  }
    200209  if ( (!cause) || (cause & 0x803d00)) {
    201210       sc->intr_errsts[sc->intr_err_ptr2++]=cause;
     
    236245
    237246#ifndef GE_NOTX
    238   GTeth_tx_start(sc, GE_TXPRIO_HI);
     247  GTeth_tx_start(sc);
    239248#endif
    240249
     
    287296  sc->arpcom.ac_if.if_flags &= ~IFF_RUNNING;
    288297#ifndef GE_NOTX
    289   GTeth_tx_stop(sc, GE_WHACK_STOP);
     298  GTeth_tx_stop(sc);
    290299#endif
    291300#ifndef GE_NORX
    292   GTeth_rx_stop(sc, GE_WHACK_STOP);
     301  GTeth_rx_stop(sc);
    293302#endif
    294303  sc->sc_hashtable = NULL;
     
    524533  printf("     Receive Packets:%-8lu\n", ifp->if_ipackets);
    525534  printf("     Receive  errors:%-8lu\n", ifp->if_ierrors);
    526   printf(" Missed Frame errors:%-8u\n",  GTeth_MissedFrame_err);
    527535  printf("      Framing Errors:%-8lu\n", sc->stats.frame_errors);
    528536  printf("          Crc Errors:%-8lu\n", sc->stats.crc_errors);
     
    535543  printf("    Tx/Rx collisions:%-8lu\n", ifp->if_collisions);
    536544  printf("         Active Txqs:%-8u\n", sc->txq_nactive);
    537 }
    538 
    539 void GT64260eth_err()
    540 {
    541   printf(" Missed Frame errors:%-8u\n", GTeth_MissedFrame_err);
    542545}
    543546
     
    678681}
    679682
    680 static void GTeth_rxprio_setup(struct GTeth_softc *sc, enum GTeth_rxprio rxprio)
    681 {
    682 
    683   if (GTeth_debug>0) printk("GTeth_rxprio_setup(\n");
     683void GTeth_rxprio_setup(struct GTeth_softc *sc)
     684{
     685
    684686  GTeth_init_rx_ring(sc);
    685687
    686   sc->rxq_intrbits = ETH_IR_RxBuffer | ETH_IR_RxError;
    687 
    688   switch (rxprio) {
    689     case GE_RXPRIO_HI:
    690       sc->rxq_intrbits |= ETH_IR_RxBuffer_3|ETH_IR_RxError_3;
    691          break;
    692     case GE_RXPRIO_MEDHI:
    693          sc->rxq_intrbits |= ETH_IR_RxBuffer_2|ETH_IR_RxError_2;
    694          break;
    695     case GE_RXPRIO_MEDLO:
    696          sc->rxq_intrbits |= ETH_IR_RxBuffer_1|ETH_IR_RxError_1;
    697          break;
    698     case GE_RXPRIO_LO:
    699          sc->rxq_intrbits |= ETH_IR_RxBuffer_0|ETH_IR_RxError_0;
    700          break;
    701   }
    702   if (GTeth_debug>0) printk(")");
    703 }
    704 
    705 static int GT64260eth_rx(struct GTeth_softc *sc, enum GTeth_rxprio rxprio)
     688  sc->rxq_intrbits = ETH_IR_RxBuffer|ETH_IR_RxError|ETH_IR_RxBuffer_3|ETH_IR_RxError_3;
     689}
     690
     691static int GT64260eth_rx(struct GTeth_softc *sc)
    706692{
    707693  struct ifnet *ifp = &sc->arpcom.ac_if;
     
    709695  int nloops=0;
    710696
     697#ifdef GT_DEBUG
    711698  if (GTeth_rx_debug>0) printk("GT64260eth_rx(");
    712   if (GTeth_rx_debug>5) printk("(%d)", rxprio);
     699#endif
    713700
    714701  while (sc->rxq_active > 0) {
     
    750737     */
    751738
    752     if (GTeth_rx_debug>0) printk("desc%d: cmdsts=%x, len=%d\n",
    753            sc->rxq_fi,cmdsts,byteCount);
    754739    nloops++;
    755740    /*
     
    759744     */
    760745    if ((cmdsts & (RX_CMD_F|RX_CMD_L|RX_STS_ES)) !=
    761                             (RX_CMD_F|RX_CMD_L) ||
    762                     byteCount > sc->sc_max_frame_length) {
    763         if (GTeth_rx_debug>0) printk("Rx Error");
    764         --sc->rxq_active;
    765         ifp->if_ipackets++;
    766         ifp->if_ierrors++;
     746                            (RX_CMD_F|RX_CMD_L) ||
     747                    byteCount > sc->sc_max_frame_length) {
     748        --sc->rxq_active;
     749        ifp->if_ipackets++;
     750        ifp->if_ierrors++;
    767751        if (cmdsts & RX_STS_OR) sc->stats.or_errors++;
    768752        if (cmdsts & RX_STS_CE) sc->stats.crc_errors++;
    769         if (cmdsts & RX_STS_MFL) sc->stats.length_errors++;
    770         if (cmdsts & RX_STS_SF) sc->stats.frame_errors++;
    771         /*      if (cmdsts & RX_STS_M) GTeth_MissedFrame_err++;*/
     753        if (cmdsts & RX_STS_MFL) sc->stats.length_errors++;
     754        if (cmdsts & RX_STS_SF) sc->stats.frame_errors++;
    772755        if ((cmdsts & RX_STS_LC) || (cmdsts & RX_STS_COL))
    773            ifp->if_collisions++;
    774         goto give_it_back;
     756           ifp->if_collisions++;
     757        goto give_it_back;
    775758     }
    776 
    777759     m = sc->rxq_mbuf[sc->rxq_fi];
    778      sc->rxq_mbuf[sc->rxq_fi] = NULL;
    779760     m->m_len = m->m_pkthdr.len = byteCount - sizeof(struct ether_header);
    780761     eh = mtod (m, struct ether_header *);
    781762     m->m_data += sizeof(struct ether_header);
    782763     ether_input (ifp, eh, m);
    783      if (GTeth_rx_debug>20) {
    784        if ( m->m_flags & M_BCAST ) printk("desc%d broadcast\n",sc->rxq_fi);
    785        if ( m->m_flags & M_MCAST ) printk("multicast ");
    786      }
    787764
    788765     ifp->if_ipackets++;
     
    804781     sc->rxq_active++;
    805782  } /* while (sc->rxq_active > 0) */
     783#ifdef GT_DEBUG
    806784  if (GTeth_rx_debug>0) printk(")");
     785#endif
    807786  return nloops;
    808787}
     
    813792  if (GTeth_rx_debug>0) printk("GTeth_rx_setup(");
    814793
    815   GTeth_rxprio_setup(sc, GE_RXPRIO_HI);
     794  GTeth_rxprio_setup(sc);
    816795
    817796  if ((sc->sc_flags & GE_RXACTIVE) == 0) {
     
    830809}
    831810
    832 static void GTeth_rx_cleanup(struct GTeth_softc *sc, enum GTeth_rxprio rxprio)
     811static void GTeth_rx_cleanup(struct GTeth_softc *sc)
    833812{
    834813  int i;
    835814
    836815  if (GTeth_rx_debug>0) printk( "GTeth_rx_cleanup(");
    837   if (sc->rxq_curpkt)
    838      m_freem(sc->rxq_curpkt);
    839816
    840817  for (i=0; i< RX_RING_SIZE; i++) {
     
    847824}
    848825
    849 static void GTeth_rx_stop(struct GTeth_softc *sc, enum GTeth_whack_op op)
     826static void GTeth_rx_stop(struct GTeth_softc *sc)
    850827{
    851828  if (GTeth_rx_debug>0) printk( "GTeth_rx_stop(");
     
    858835     rtems_bsp_delay(10);
    859836  } while (inl(ETH0_ESDCMR) & ETH_ESDCMR_AR);
    860   GTeth_rx_cleanup(sc, GE_RXPRIO_HI);
     837  GTeth_rx_cleanup(sc);
    861838  if (GTeth_rx_debug>0) printk(")");
    862839}
     
    930907}
    931908
    932 static int GT64260eth_sendpacket(struct GTeth_softc *sc,struct mbuf *m, enum GTeth_txprio txprio)
     909static int GT64260eth_sendpacket(struct GTeth_softc *sc,struct mbuf *m)
    933910{
    934911  volatile struct GTeth_desc *txd = &sc->txq_desc[sc->txq_lo];
    935912  unsigned intrmask = sc->sc_intrmask;
    936913  unsigned index= sc->txq_lo;
    937 
    938   if (GTeth_debug>0) printk("sendpacket(");
    939914
    940915  /*
     
    988963  txd->ed_bufptr = (unsigned) mtod(m, void*);
    989964  txd->ed_lencnt = m->m_len << 16;
    990   txd->ed_cmdsts = TX_CMD_L|TX_CMD_GC|TX_CMD_P|TX_CMD_O|TX_CMD_F|TX_CMD_EI;
     965  /*txd->ed_cmdsts = TX_CMD_L|TX_CMD_GC|TX_CMD_P|TX_CMD_O|TX_CMD_F|TX_CMD_EI;*/
     966  txd->ed_cmdsts = 0x80c70000;
    991967
    992968#ifdef GT_DEBUG
     
    996972  /*
    997973   * Tell the SDMA engine to "Fetch!"
    998    * Start Tx high and Tx low.
    999    */
    1000   outl(ETH_ESDCMR_TXDH,ETH0_ESDCMR);
     974   * Start Tx high.
     975   */
    1001976  sc->txq_nactive++;
     977  outl(0x800080, ETH0_ESDCMR); /* ETH_ESDCMR_TXDH| ETH_ESDCMR_ERD */
    1002978  if ( ++sc->txq_lo == TX_RING_SIZE) sc->txq_lo = 0;
    1003979  sc->txq_free--;
    1004980
     981#if 0
    1005982  /*
    1006983   * Since we have put an item into the packet queue, we now want
     
    1013990      outl(sc->sc_intrmask, ETH0_EIMR);
    1014991  }
     992#endif
    1015993
    1016994#if 0
     
    1021999#endif
    10221000
    1023   if (GTeth_debug>0) printk(")");
    10241001  return 1;
    10251002}
    10261003
    1027 static unsigned GTeth_txq_done(struct GTeth_softc *sc, enum GTeth_txprio txprio)
     1004static unsigned GTeth_txq_done(struct GTeth_softc *sc)
    10281005{
    10291006  if (GTeth_debug>0) printk("Txdone(" );
     
    10721049}
    10731050
    1074 static void GTeth_tx_start(struct GTeth_softc *sc, enum GTeth_txprio txprio)
     1051static void GTeth_tx_start(struct GTeth_softc *sc)
    10751052{
    10761053  int i;
     
    11181095#endif
    11191096  }
    1120 
    1121   switch (txprio) {
    1122     case GE_TXPRIO_HI:
    1123       sc->txq_intrbits = ETH_IR_TxEndHigh|ETH_IR_TxBufferHigh;
    1124          sc->txq_esdcmrbits = ETH_ESDCMR_TXDH; /* Start Tx high */
    1125          sc->txq_epsrbits = ETH_EPSR_TxHigh;
    1126          /* offset to current tx desc ptr reg */
    1127          sc->txq_ectdp = (caddr_t)ETH0_ECTDP1;
    1128          /* Current Tx Desc Pointer 1 */
    1129          outl(sc->txq_desc_busaddr,ETH0_ECTDP1);
    1130 #ifdef GT_DEBUG
    1131          printk("ETH0_ECTDP1 %x",inl(ETH0_ECTDP1));
    1132 #endif
    1133          break;
    1134 
    1135     case GE_TXPRIO_LO:
    1136          sc->txq_intrbits = ETH_IR_TxEndLow|ETH_IR_TxBufferLow;
    1137          sc->txq_esdcmrbits = ETH_ESDCMR_TXDL; /* Start TX low */
    1138          sc->txq_epsrbits = ETH_EPSR_TxLow;
    1139          sc->txq_ectdp = (caddr_t)ETH0_ECTDP0;
    1140          /* Current Tx Desc Pointer 0 */
    1141          outl(sc->txq_desc_busaddr,ETH0_ECTDP0);
    1142 #ifdef GT_DEBUG
    1143          printk("ETH0_ECTDP1 %x",inl(ETH0_ECTDP0));
    1144 #endif
    1145          break;
    1146 
    1147     default:
    1148          printk("Invalid Txq prio\n");
    1149          break;
    1150   }
    11511097 
     1098  sc->txq_intrbits = ETH_IR_TxEndHigh|ETH_IR_TxBufferHigh;
     1099  sc->txq_esdcmrbits = ETH_ESDCMR_TXDH; /* Start Tx high */
     1100  sc->txq_epsrbits = ETH_EPSR_TxHigh;
     1101  /* offset to current tx desc ptr reg */
     1102  sc->txq_ectdp = (caddr_t)ETH0_ECTDP1;
     1103  /* Current Tx Desc Pointer 1 */
     1104  outl(sc->txq_desc_busaddr,ETH0_ECTDP1);
     1105
    11521106#ifdef GT_DEBUG
    11531107  printk(")\n");
     
    11551109}
    11561110
    1157 static void GTeth_tx_cleanup(struct GTeth_softc *sc,enum GTeth_txprio txprio,int flush)
     1111static void GTeth_tx_cleanup(struct GTeth_softc *sc)
    11581112{
    11591113  int i;
    11601114
    1161   if (GTeth_debug>0) printk( "GTeth_tx_cleanup(");
    1162 
    1163   if (!flush) {
    1164      if (GTeth_debug>0) printk("--");
    1165      return;
    1166   }
    11671115  for (i=0; i< TX_RING_SIZE; i++) {
    11681116    if (sc->txq_mbuf[i]) {
     
    11711119    }
    11721120  }
    1173   if (GTeth_debug>0) printk(")");
    1174 }
    1175 
    1176 static void GTeth_tx_stop(struct GTeth_softc *sc, enum GTeth_whack_op op)
    1177 {
    1178   if (GTeth_debug>0) printk("GTeth_tx_stop( ");
    1179 
     1121}
     1122
     1123static void GTeth_tx_stop(struct GTeth_softc *sc)
     1124{
    11801125  /* SDMA command register : stop Tx high and low */
    11811126  outl(ETH_ESDCMR_STDH|ETH_ESDCMR_STDL, ETH0_ESDCMR);
    11821127
    1183   GTeth_txq_done(sc, GE_TXPRIO_HI);
     1128  GTeth_txq_done(sc);
    11841129  sc->sc_intrmask &= ~(ETH_IR_TxEndHigh|ETH_IR_TxBufferHigh|
    1185                              ETH_IR_TxEndLow |ETH_IR_TxBufferLow);
    1186   GTeth_tx_cleanup(sc, GE_TXPRIO_HI, op == GE_WHACK_STOP);
     1130                             ETH_IR_TxEndLow |ETH_IR_TxBufferLow);
     1131  GTeth_tx_cleanup(sc);
    11871132
    11881133  sc->arpcom.ac_if.if_timer = 0;
    1189   if (GTeth_debug>0) printk(")");
    1190 }
    1191 
     1134}
    11921135
    11931136/* TOCHECK : Should it be about rx or tx ? */
     
    12281171  add1 = ((add1 & 0x00aaaaaa) >> 1) | ((add1 & 0x00555555) << 1);
    12291172
    1230   if (GTeth_debug>0) printk("eaddr= %s add1:%x add0:%x\n", ether_sprintf(eaddr), add1, add0);
     1173#ifdef GT_DEBUG
     1174  printk("eaddr= %s add1:%x add0:%x\n", ether_sprintf1(eaddr), add1, add0);
     1175#endif
    12311176   
    12321177  /*
     
    12511196      */
    12521197     result |= (add0 & ~3) << 7;        /* excess bits will be masked */
    1253      if (GTeth_debug>0) printk("hash result %x  ", result & 0x7fff);
     1198#ifdef GT_DEBUG
     1199     printk("hash result %x  ", result & 0x7fff);
     1200#endif
    12541201  } else {
    12551202#define TRIBITFLIP      073516240       /* yes its in octal */
     
    12751222     result |= ((TRIBITFLIP >> (((add0 >> 0) & 7) * 3)) & 7) << 12;
    12761223     result |= ((TRIBITFLIP >> (((add0 >> 3) & 7) * 3)) & 7) << 9;
    1277      if (GTeth_debug>5) printk("1(%#x)", result);
    1278   }
    1279   if (GTeth_debug>0) printk(")");
     1224#ifdef GT_DEBUG
     1225     printk("1(%#x)", result);
     1226#endif
     1227  }
     1228#ifdef GT_DEBUG
     1229  printk(")");
     1230#endif
     1231
    12801232  /* 1/2K address filtering (MOTLoad default )? ->16KB memory required
    12811233   * or 8k address filtering ? -> 256KB memory required
     
    12931245  int maybe_hash = 0;
    12941246
    1295   if (GTeth_debug>0) printk("GTeth_hash_entry_op(prio %d ", prio);
     1247#ifdef GT_DEBUG
     1248  printk("GTeth_hash_entry_op(prio %d ", prio);
     1249#endif
    12961250
    12971251  hash = GTeth_hash_compute(sc, eaddr);
     
    13001254        rtems_panic("hashtable == NULL!");
    13011255  }
    1302   if (GTeth_debug>0) printk("Hash computed %x eaddr %s\n", hash,ether_sprintf(eaddr));
    1303 
     1256#ifdef GT_DEBUG
     1257  printk("Hash computed %x eaddr %s\n", hash,ether_sprintf1(eaddr));
     1258#endif
    13041259
    13051260  /*
     
    13211276  hash &= (sc->sc_hashmask / sizeof(he));
    13221277
     1278#ifdef GT_DEBUG
    13231279  if (GTeth_debug>0) {
    13241280    unsigned val1, val2;
     
    13261282    val1= he & 0xffffffff;
    13271283    val2= (he >>32) & 0xffffffff;
    1328     printk("Hash addr value %x%x, entry %x\n",val2,val1, hash);
    1329   }
     1284    printk("Hash addr value %x%x, entry %x\n",val2,val1, hash);
     1285  }
     1286#endif
    13301287
    13311288  for (limit = HSH_LIMIT; limit > 0 ; --limit) {
     
    14251382  int error;
    14261383
    1427   if (GTeth_debug>0) printk( "GTeth_hash_fill(");
     1384#ifdef GT_DEBUG
     1385  printk( "GTeth_hash_fill(");
     1386#endif
    14281387  error = GTeth_hash_entry_op(sc,GE_HASH_ADD,GE_RXPRIO_HI,sc->arpcom.ac_enaddr);
    14291388
     
    14531412    ETHER_NEXT_MULTI(step, enm);
    14541413  }
    1455   if (GTeth_debug>0) printk(")\n");
     1414#ifdef GT_DEBUG
     1415  printk(")\n");
     1416#endif
    14561417  return error;
    14571418}
     
    14761437
    14771438  memset((void *)sc->sc_hashtable, 0,HASH_DRAM_SIZE);
    1478   if (GTeth_debug>0)
    1479     printk("hashtable addr:%x, mask %x)\n", sc->sc_hashtable,sc->sc_hashmask);
     1439#ifdef GT_DEBUG
     1440  printk("hashtable addr:%x, mask %x)\n", sc->sc_hashtable,sc->sc_hashmask);
     1441#endif
    14801442}
    14811443
     
    15491511
    15501512#ifndef GE_NORX
    1551      if (events & RX_EVENT) GT64260eth_rx(sc,GE_RXPRIO_HI);
     1513     if (events & RX_EVENT) GT64260eth_rx(sc);
     1514#endif
     1515#if 0
     1516     printk("%x ", inb(ETH0_EPSR));
     1517     if ( ((i++) % 15)==0) printk("\n");
    15521518#endif
    15531519
    15541520     /* clean up and try sending packets */
    15551521     do {
    1556 #if 1
     1522#if 0
    15571523        if (gpp_int_error!=0) {
    15581524           printk("GPP interrupt error %d\n", gpp_int_error);
     
    15601526        }
    15611527#endif
    1562          if (sc->txq_nactive) GTeth_txq_done(sc, GE_TXPRIO_HI);
     1528         if (sc->txq_nactive) GTeth_txq_done(sc);
    15631529
    15641530         while (sc->txq_free>0) {
     
    15671533              IF_DEQUEUE(&ifp->if_snd,m);
    15681534              if (m==0) break;
    1569               GT64260eth_sendpacket(sc, m, GE_TXPRIO_HI);
     1535              GT64260eth_sendpacket(sc, m);
    15701536           }
    15711537           else {
    1572              if (txq_high_limit(sc))
    1573                  break;
     1538              GTeth_txq_done(sc);
     1539              break;
    15741540           }
    15751541         }
Note: See TracChangeset for help on using the changeset viewer.