Changeset 81c32419 in rtems


Ignore:
Timestamp:
Jun 30, 2003, 6:14:47 PM (18 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Children:
fb6d373
Parents:
673df26e
Message:

2003-06-30 Greg Menke <gregory.menke@…>

  • network/dec21140.c, network/elnk.c: Update to compile on i386.
Location:
c/src/libchip
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • c/src/libchip/ChangeLog

    r673df26e r81c32419  
     12003-06-30      Greg Menke <gregory.menke@gsfc.nasa.gov>
     2
     3        * network/dec21140.c, network/elnk.c: Update to compile on i386.
     4
    152003-06-13      Greg Menke <gregory.menke@gsfc.nasa.gov>
    26
  • c/src/libchip/network/dec21140.c

    r673df26e r81c32419  
    108108#define DRIVER_PREFIX   "dc"
    109109
    110 #define IO_MASK  0x3
     110#define IO_MASK   0x3
    111111#define MEM_MASK  0xF
    112112
     
    272272
    273273      rtems_irq_connect_data    irqInfo;
    274 
    275274      rtems_event_set           ioevent;
     275
     276      int                       numRxbuffers, numTxbuffers;
    276277
    277278      volatile struct MD        *MDbase;
     
    517518    * Init RX ring
    518519    */
    519    cp = (volatile unsigned char *)malloc(((NRXBUFS+NTXBUFS)*sizeof(struct MD))
    520                                          + (NTXBUFS*RBUF_SIZE)
     520   cp = (volatile unsigned char *)malloc(((sc->numRxbuffers+sc->numTxbuffers)*sizeof(struct MD))
     521                                         + (sc->numTxbuffers*RBUF_SIZE)
    521522                                         + CPU_CACHE_ALIGNMENT_FOR_BUFFER);
    522523   sc->bufferBase = cp;
     
    527528      _CPU_change_memory_mapping_attribute
    528529         (NULL, cp,
    529           ((NRXBUFS+NTXBUFS)*sizeof(struct MD))
    530           + (NTXBUFS*RBUF_SIZE),
     530          ((sc->numRxbuffers+sc->numTxbuffers)*sizeof(struct MD))
     531          + (sc->numTxbuffers*RBUF_SIZE),
    531532          PTE_CACHE_DISABLE | PTE_WRITABLE);
    532533#endif
     
    536537   sc->nextRxMD = sc->MDbase;
    537538
    538    buffer = cp + ((NRXBUFS+NTXBUFS)*sizeof(struct MD));
     539   buffer = cp + ((sc->numRxbuffers+sc->numTxbuffers)*sizeof(struct MD));
    539540   st_le32( (tbase+memCSR3), (long)(phys_to_bus((long)(sc->MDbase))));
    540541
    541    for (i=0 ; i<NRXBUFS; i++)
     542   for (i=0 ; i<sc->numRxbuffers; i++)
    542543   {
    543544      struct mbuf *m;
     
    559560    * mark last RX buffer.
    560561    */
    561    sc->MDbase [NRXBUFS-1].buf2   = 0;
    562    sc->MDbase [NRXBUFS-1].counts = 0xfec00000 | (RBUF_SIZE);
    563    sc->MDbase [NRXBUFS-1].next   = sc->MDbase;
     562   sc->MDbase [sc->numRxbuffers-1].buf2   = 0;
     563   sc->MDbase [sc->numRxbuffers-1].counts = 0xfec00000 | (RBUF_SIZE);
     564   sc->MDbase [sc->numRxbuffers-1].next   = sc->MDbase;
    564565
    565566
     
    569570    */
    570571   st_le32( (tbase+memCSR4), (long)(phys_to_bus((long)(rmd))) );
    571    for (i=0 ; i<NTXBUFS; i++){
     572   for (i=0 ; i<sc->numTxbuffers; i++){
    572573      (rmd+i)->buf2   = phys_to_bus(rmd+i+1);
    573574      (rmd+i)->buf1   = phys_to_bus(buffer + (i*RBUF_SIZE));
     
    581582    * mark last TX buffer.
    582583    */
    583    (rmd+NTXBUFS-1)->buf2   = phys_to_bus(rmd);
    584    (rmd+NTXBUFS-1)->next   = rmd;
     584   (rmd+sc->numTxbuffers-1)->buf2   = phys_to_bus(rmd);
     585   (rmd+sc->numTxbuffers-1)->next   = rmd;
    585586
    586587
     
    649650   volatile struct MD    *rmd;
    650651   struct dec21140_softc *sc;
    651    volatile struct ifnet *ifp;
     652   struct ifnet          *ifp;
    652653   struct ether_header   *eh;
    653654   struct mbuf           *m;
     
    11241125   sc->ioevent = unit_signals[unitNumber-1];
    11251126
     1127   /*
     1128   ** Save the buffer counts
     1129   */
     1130   sc->numRxbuffers = (config->rbuf_count) ? config->rbuf_count : NRXBUFS;
     1131   sc->numTxbuffers = (config->xbuf_count) ? config->xbuf_count : NTXBUFS;
     1132
    11261133
    11271134   /*
     
    11801187   ** Prep the board
    11811188   */
     1189
     1190#if defined(__PPC)
    11821191   pci_write_config_word(pbus, pdev, pfun,
    11831192                         PCI_COMMAND,
    1184                          (unsigned16)( PCI_COMMAND_MEMORY |
    1185                                        PCI_COMMAND_MASTER |
    1186                                        PCI_COMMAND_INVALIDATE |
    1187                                        PCI_COMMAND_WAIT |
    1188                                        PCI_COMMAND_FAST_BACK ) );
     1193                         (unsigned16) ( PCI_COMMAND_MEMORY |
     1194                                        PCI_COMMAND_MASTER |
     1195                                        PCI_COMMAND_INVALIDATE |
     1196                                        PCI_COMMAND_WAIT |
     1197                                        PCI_COMMAND_FAST_BACK ) );
     1198#endif
     1199#if defined(__i386__)
     1200   pcib_conf_write16(signature, 0x04, ( 0x2 | 0x4 | 0x10 | 0x80 | 0x200) );
     1201#endif
     1202
    11891203
    11901204   /*
  • c/src/libchip/network/elnk.c

    r673df26e r81c32419  
    2828 * this file.
    2929 *
    30  * Greg Menke
     30 * Greg Menke, 6/11/2003
    3131 */
    3232
     
    7171 */
    7272
     73/*
    7374#if defined(__i386__)
    7475#define ELNK_SUPPORTED
    7576#endif
     77*/
    7678
    7779#if defined(__PPC__) && (defined(mpc604) || defined(mpc750) || defined(mpc603e))
     
    188190
    189191
     192
     193
    190194#if defined(__PPC)
    191195#define phys_to_bus(address) ((unsigned int)((address)) + PCI_DRAM_OFFSET)
     
    211215
    212216/* the actual duration waited in DELAY is not especially predictable,
    213  * though it will be consistent.  It should not be relied upon for
    214  * specific timing given the vague per-bsp, per-architecture
    215  * implementation of the actual delay function.  It would probably be
    216  * helpful to make this more accurate at some point...
     217 * though it will be consistent on a given host.  It should not be
     218 * relied upon for specific timing given the vague per-bsp,
     219 * per-architecture implementation of the actual delay function.  It
     220 * would probably be helpful to make this more accurate at some point...
    217221 */
    218222#define DELAY(n)        rtems_bsp_delay_in_bus_cycles( n*20  )
     
    315319 */
    316320#define XL_INTRS        \
    317         (XL_STAT_UP_COMPLETE|XL_STAT_STATSOFLOW|XL_STAT_ADFAIL| \
    318          XL_STAT_DOWN_COMPLETE|XL_STAT_TX_COMPLETE|XL_STAT_INTLATCH)
     321                  (XL_STAT_UP_COMPLETE | XL_STAT_STATSOFLOW | XL_STAT_ADFAIL|   \
     322                   XL_STAT_DOWN_COMPLETE | XL_STAT_TX_COMPLETE | XL_STAT_INTLATCH)
    319323
    320324
     
    754758struct xl_stats
    755759{
    756       u_int8_t          xl_carrier_lost;
    757       u_int8_t          xl_sqe_errs;
    758       u_int8_t          xl_tx_multi_collision;
    759       u_int8_t          xl_tx_single_collision;
    760       u_int8_t          xl_tx_late_collision;
    761       u_int8_t          xl_rx_overrun;
    762       u_int8_t          xl_tx_frames_ok;
    763       u_int8_t          xl_rx_frames_ok;
    764       u_int8_t          xl_tx_deferred;
    765       u_int8_t          xl_upper_frames_ok;
    766       u_int16_t         xl_rx_bytes_ok;
    767       u_int16_t         xl_tx_bytes_ok;
    768 
    769       u_int8_t          xl_upper_bytes_ok;
    770       u_int8_t          xl_badssd;
    771 
     760      /* accumulated stats */
     761      u_int16_t         xl_carrier_lost;
     762      u_int16_t         xl_sqe_errs;
     763      u_int16_t         xl_tx_multi_collision;
     764      u_int16_t         xl_tx_single_collision;
     765      u_int16_t         xl_tx_late_collision;
     766      u_int16_t         xl_rx_overrun;
     767      u_int16_t         xl_tx_deferred;
     768
     769      u_int32_t         xl_rx_bytes_ok;
     770      u_int32_t         xl_tx_bytes_ok;
     771
     772      u_int32_t         xl_tx_frames_ok;
     773      u_int32_t         xl_rx_frames_ok;
     774
     775      u_int16_t         xl_badssd;
     776
     777      /* non-accumulated stats */
    772778      u_int16_t         intstatus;
    773779      u_int16_t         rxstatus;
     
    778784
    779785      u_int32_t         device_interrupts;
     786      u_int32_t         internalconfig;
     787      u_int16_t         mac_control;
    780788
    781789      u_int16_t         smbstatus;
     790      u_int32_t         dmactl;
     791      u_int16_t         txfree;
    782792};
    783793
     
    863873#define CSR_WRITE_1(sc, reg, val)       outb( val, sc->ioaddr + reg)
    864874
    865 #define CSR_READ_4(sc, reg)     inl(sc->ioaddr + reg)
    866 #define CSR_READ_2(sc, reg)     inw(sc->ioaddr + reg)
    867 #define CSR_READ_1(sc, reg)     inb(sc->ioaddr + reg)
    868 
    869 #define XL_SEL_WIN(x)           CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_WINSEL | x)
     875#define CSR_READ_4(sc, reg)             inl(sc->ioaddr + reg)
     876#define CSR_READ_2(sc, reg)             inw(sc->ioaddr + reg)
     877#define CSR_READ_1(sc, reg)             inb(sc->ioaddr + reg)
     878
     879#define XL_SEL_WIN(x)                   CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_WINSEL | x)
    870880
    871881#define XL_TIMEOUT              1000
     
    875885
    876886
    877 /* message descriptor entry, ensure this struct is aligned to 8 bytes */
    878 struct MD
     887
     888/* rx message descriptor entry, ensure the struct is aligned to 8 bytes */
     889struct RXMD
    879890{
    880891      /* used by hardware */
     
    885896      /* used by software */
    886897      struct mbuf       *mbuf;        /* scratch variable used in the tx ring */
    887       struct MD         *next_md;
     898      struct RXMD       *next_md;
     899} __attribute__ ((aligned (8), packed));
     900
     901
     902
     903
     904
     905#define NUM_FRAGS       8
     906
     907/*
     908 * tx message descriptor entry, ensure the struct is aligned to 8 bytes
     909 */
     910
     911struct tfrag
     912{
     913      volatile unsigned32 addr;
     914      volatile unsigned32 length;
    888915} __attribute__ ((packed));
    889916
    890 
    891 
    892 
     917struct TXMD
     918{
     919      /* used by hardware */
     920      volatile unsigned32 next;
     921      volatile unsigned32 status;
     922      struct tfrag        txfrags[NUM_FRAGS];
     923      /* used by software */
     924      struct mbuf       *mbuf;        /* scratch variable used in the tx ring */
     925      struct TXMD       *next_md, *chainptr;
     926} __attribute__ ((aligned (8), packed));
     927
     928
     929
     930
     931
     932#define NUM_CHAIN_LENGTHS       50
    893933
    894934
     
    905945      unsigned int              ioaddr;
    906946
    907       volatile unsigned char    *bufferBase, *ringBase;
    908 
    909       struct MD                 *curr_rx_md, *last_tx_md, *last_txchain_head;
     947      unsigned char             *bufferBase, *ringBase;
     948
     949      struct RXMD      *rx_ring, *curr_rx_md;
     950      struct TXMD      *tx_ring, *last_tx_md, *last_txchain_head;
    910951
    911952      rtems_id                  stat_timer_id;
     
    925966      int                       tx_idle;
    926967
     968      short                     chain_lengths[NUM_CHAIN_LENGTHS];
     969      int                       chlenIndex;
     970
    927971      unsigned short            vendorID, deviceID;
    928972      int                       acceptBroadcast;
     
    933977static rtems_id rxDaemonTid;
    934978static rtems_id txDaemonTid;
     979static rtems_id chainRecoveryQueue;
    935980
    936981
     
    9551000static void
    9561001xl_wait(sc)
    957    struct elnk_softc            *sc;
     1002   struct elnk_softc    *sc;
    9581003{
    9591004   register int         i;
    9601005
    961    for (i = 0; i < XL_TIMEOUT; i++) {
     1006   for(i = 0; i < XL_TIMEOUT; i++)
     1007   {
    9621008      if (!(CSR_READ_2(sc, XL_STATUS) & XL_STAT_CMDBUSY))
    9631009         break;
     
    9651011
    9661012   if (i == XL_TIMEOUT)
    967       printk("ek%d: command never completed!\n", sc->xl_unit);
    968 
     1013      printk("etherlink : unit elnk%d command never completed\n", sc->xl_unit );
    9691014   return;
    9701015}
     
    11731218static int
    11741219xl_miibus_readreg(sc, phy, reg)
    1175    struct elnk_softc            *sc;
     1220   struct elnk_softc    *sc;
    11761221   int                  phy, reg;
    11771222{
     
    11911236   }
    11921237
    1193    bzero((char *)&frame, sizeof(frame));
     1238   memset((char *)&frame, 0, sizeof(frame));
    11941239
    11951240   frame.mii_phyaddr = phy;
     
    12131258   }
    12141259
    1215    bzero((char *)&frame, sizeof(frame));
     1260   memset((char *)&frame, 0, sizeof(frame));
    12161261
    12171262   frame.mii_phyaddr = phy;
     
    13141359   void *xsc;
    13151360{
    1316    volatile struct elnk_softc   *sc = (struct elnk_softc *)xsc;
    1317    volatile struct ifnet        *ifp = &sc->arpcom.ac_if;
    1318 
    1319    int  i;
     1361   struct elnk_softc    *sc = (struct elnk_softc *)xsc;
     1362   struct ifnet         *ifp = &sc->arpcom.ac_if;
     1363   u_int32_t            t1;
    13201364
    13211365   sc->xl_stats.intstatus = CSR_READ_2(sc, XL_STATUS);
    1322 
     1366   
    13231367   sc->xl_stats.miianr    = xl_miibus_readreg(sc, 0x18, MII_ANAR );
    13241368   sc->xl_stats.miipar    = xl_miibus_readreg(sc, 0x18, MII_ANLPAR );
    13251369   sc->xl_stats.miistatus = xl_miibus_readreg(sc, 0x18, MII_BMSR );
    13261370   sc->xl_stats.miicmd    = xl_miibus_readreg(sc, 0x18, MII_BMCR );
     1371   
     1372   XL_SEL_WIN(1);
     1373   sc->xl_stats.rxstatus  = CSR_READ_2(sc, XL_W1_RX_STATUS );
     1374   sc->xl_stats.txstatus  = CSR_READ_1(sc, XL_W1_TX_STATUS );
     1375   sc->xl_stats.smbstatus = CSR_READ_2(sc, 2 );
     1376
     1377   XL_SEL_WIN(3);
     1378   sc->xl_stats.internalconfig = CSR_READ_4(sc, XL_W3_INTERNAL_CFG);
     1379   sc->xl_stats.mac_control    = CSR_READ_2(sc, XL_W3_MAC_CTRL);
     1380   sc->xl_stats.txfree         = CSR_READ_2(sc, XL_W3_FREE_TX );
    13271381     
    1328    XL_SEL_WIN(1);
    1329    sc->xl_stats.rxstatus = CSR_READ_2(sc, XL_W1_RX_STATUS );
    1330    sc->xl_stats.txstatus = CSR_READ_1(sc, XL_W1_TX_STATUS );
    1331    sc->xl_stats.smbstatus = CSR_READ_2(sc, 2 );
    13321382
    13331383   /* Read all the stats registers. */
     
    13401390   sc->xl_stats.xl_tx_late_collision         += CSR_READ_1(sc, XL_W6_COL_LATE);
    13411391   sc->xl_stats.xl_rx_overrun                += CSR_READ_1(sc, XL_W6_RX_OVERRUN);
     1392   sc->xl_stats.xl_tx_deferred               += CSR_READ_1(sc, XL_W6_DEFERRED);
     1393
    13421394   sc->xl_stats.xl_tx_frames_ok              += CSR_READ_1(sc, XL_W6_TX_OK);
    13431395   sc->xl_stats.xl_rx_frames_ok              += CSR_READ_1(sc, XL_W6_RX_OK);
    1344    sc->xl_stats.xl_tx_deferred               += CSR_READ_1(sc, XL_W6_DEFERRED);
    1345    sc->xl_stats.xl_upper_frames_ok           += CSR_READ_1(sc, XL_W6_UPPER_FRAMES_OK);
    13461396
    13471397   sc->xl_stats.xl_rx_bytes_ok               += CSR_READ_2(sc, XL_W6_TX_BYTES_OK );
    13481398   sc->xl_stats.xl_tx_bytes_ok               += CSR_READ_2(sc, XL_W6_RX_BYTES_OK );
    13491399
    1350 /*
    1351    for (i = 0; i < 16; i++)
    1352    *p++ = CSR_READ_1(sc, XL_W6_CARRIER_LOST + i);
    1353 */
     1400   t1 = CSR_READ_1(sc, XL_W6_UPPER_FRAMES_OK);
     1401   sc->xl_stats.xl_rx_frames_ok +=  ((t1 & 0x3) << 8);
     1402   sc->xl_stats.xl_tx_frames_ok +=  (((t1 >> 4) & 0x3) << 8);
     1403
    13541404
    13551405   ifp->if_ierrors += sc->xl_stats.xl_rx_overrun;
     
    13661416    */
    13671417   XL_SEL_WIN(4);
    1368    sc->xl_stats.xl_upper_bytes_ok       += CSR_READ_1(sc, XL_W4_UPPERBYTESOK);
     1418
     1419   t1 = CSR_READ_1(sc, XL_W4_UPPERBYTESOK);
     1420   sc->xl_stats.xl_rx_bytes_ok += ((t1 & 0xf) << 16);
     1421   sc->xl_stats.xl_tx_bytes_ok += (((t1 >> 4) & 0xf) << 16);
     1422
    13691423   sc->xl_stats.xl_badssd               += CSR_READ_1(sc, XL_W4_BADSSD);
    1370    sc->xl_stats.mediastatus              = CSR_READ_2(sc, XL_W4_MEDIA_STATUS );
     1424
     1425   sc->xl_stats.mediastatus             = CSR_READ_2(sc, XL_W4_MEDIA_STATUS );
     1426   sc->xl_stats.dmactl                  = CSR_READ_4(sc, XL_DMACTL );
     1427
    13711428
    13721429   XL_SEL_WIN(7);
     
    14171474
    14181475   if (sc->xl_flags & XL_FLAG_INVERT_LED_PWR ||
    1419        sc->xl_flags & XL_FLAG_INVERT_MII_PWR) {
     1476       sc->xl_flags & XL_FLAG_INVERT_MII_PWR)
     1477   {
    14201478      XL_SEL_WIN(2);
    14211479      CSR_WRITE_2(sc, XL_W2_RESET_OPTIONS, CSR_READ_2(sc,
     
    14381496   struct elnk_softc            *sc;
    14391497{
    1440    register int         i;
    14411498   struct ifnet         *ifp;
    14421499
     
    14841541   XL_SEL_WIN(3);
    14851542   icfg = CSR_READ_4(sc, XL_W3_INTERNAL_CFG);
     1543
    14861544   icfg &= ~XL_ICFG_CONNECTOR_MASK;
    1487    if (sc->xl_media & XL_MEDIAOPT_MII ||
    1488        sc->xl_media & XL_MEDIAOPT_BT4)
     1545
     1546   if (sc->xl_media & XL_MEDIAOPT_MII || sc->xl_media & XL_MEDIAOPT_BT4)
    14891547      icfg |= (XL_XCVR_MII << XL_ICFG_CONNECTOR_BITS);
     1548
    14901549   if (sc->xl_media & XL_MEDIAOPT_BTX)
    14911550      icfg |= (XL_XCVR_AUTO << XL_ICFG_CONNECTOR_BITS);
     
    14981557}
    14991558
     1559
     1560
    15001561static void
    15011562xl_setmode(sc, media)
    1502    struct elnk_softc            *sc;
     1563   struct elnk_softc    *sc;
    15031564   int                  media;
    15041565{
     
    15851646   else
    15861647      CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_COAX_STOP);
     1648
    15871649   CSR_WRITE_4(sc, XL_W3_INTERNAL_CFG, icfg);
    15881650   XL_SEL_WIN(4);
     
    17171779{
    17181780
     1781   xl_choose_xcvr(sc, 1);
     1782
    17191783   /*
    17201784    * If some of the media options bits are set, assume they are
     
    17481812   }
    17491813
    1750    xl_choose_xcvr(sc, 1);
    17511814   return;
    17521815}
     
    17951858
    17961859static void
    1797 elnk_start_txchain( struct elnk_softc *sc, struct MD *chaintop )
    1798 {
    1799    printk("unit elnk%d tx start\n", sc->xl_unit );
    1800 
     1860elnk_start_txchain( struct elnk_softc *sc, struct TXMD *chainhead )
     1861{
     1862   xl_wait(sc);
     1863   CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_DOWN_STALL);
     1864
     1865   /* save the address of the TX list */
     1866   sc->last_txchain_head = chainhead;
    18011867   sc->tx_idle = 0;
    18021868
    1803    /* save the address of the TX list */
    1804    sc->last_txchain_head = chaintop;
    1805 
    1806    CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_DOWN_STALL);
    18071869   xl_wait(sc);
     1870
    18081871   CSR_WRITE_4(sc, XL_DOWNLIST_PTR, phys_to_bus( sc->last_txchain_head ));
    18091872   CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_DOWN_UNSTALL);
     
    18231886   u_int16_t            status;
    18241887
    1825    while( (status = CSR_READ_2(sc, XL_STATUS)) & XL_INTRS && status != 0xFFFF)
     1888   while( ((status = CSR_READ_2(sc, XL_STATUS)) & XL_INTRS) && status != 0xFFFF)
    18261889   {
    18271890      sc->xl_stats.device_interrupts++;
    18281891
    1829       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_INTR_ACK|(status & XL_INTRS));
     1892      CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_INTR_ACK | (status & XL_INTRS));
    18301893
    18311894#if 0
     
    18441907      if (status & XL_STAT_DOWN_COMPLETE)
    18451908      {
    1846          struct MD *chaintailmd = NULL;
    1847 
    18481909         /* all packets uploaded to the device */
    1849 
    1850          if( sc->last_txchain_head->mbuf )
     1910         struct TXMD *chaintailmd = NULL;
     1911
     1912         /* send the chain head to the tx task which will recover the
     1913            whole chain */
     1914         rtems_message_queue_send( chainRecoveryQueue, &sc->last_txchain_head, sizeof(struct TXMD *));
     1915
     1916         /* set up the next chain */
     1917         if( sc->last_txchain_head->chainptr )
    18511918         {
    1852             /* either this is a chain of 2 or more packets, or its a
    1853              * single packet chain and another chain is also ready to send
     1919            /* check the head of the chain of packets we just finished,
     1920             * if != 0, either this is a chain of 2 or more packets or
     1921             * its a single packet chain and another chain is ready to
     1922             * send.
    18541923             */
    1855             if( (int)sc->last_txchain_head->mbuf == -1 )
     1924            if( (int)sc->last_txchain_head->chainptr == -1 )
    18561925            {
    1857                /* single packet was sent, no indirection to the last entry
    1858                   in the chain.  since mbuf is != 0, then another chain
    1859                   is ready */
     1926               /*
     1927               ** single packet was sent so no indirection to the last
     1928               ** entry in the chain.  since chainptr is != 0, then
     1929               ** another chain is ready starting from the packet AFTER
     1930               ** the chain we just finished. - in this case the last
     1931               ** chain's head == its tail
     1932               */
    18601933               chaintailmd = sc->last_txchain_head;
    18611934            }
    18621935            else
    18631936            {
    1864                /* otherwise, this is a pointer to the last packet in the
    1865                   chain */
    1866                chaintailmd = (struct MD *)sc->last_txchain_head->mbuf;
     1937               /*
     1938               ** otherwise, this is a pointer to the last packet in the
     1939               ** chain of 2 or more packets.  If the chain's last
     1940               ** packet's mbuf is != 0, then another chain is ready to
     1941               ** send.
     1942               */
     1943               chaintailmd = sc->last_txchain_head->chainptr;
    18671944               if( !chaintailmd->mbuf ) chaintailmd = NULL;
    18681945            }
     
    18761953         else
    18771954         {
    1878             /* otherwise, we have nothing else to send */
    1879             CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_DOWN_STALL);
     1955            /* otherwise nothing to send, so go idle */
    18801956            sc->tx_idle = -1;
     1957
     1958            /* wake up the tx daemon once so we're sure this last chain
     1959               will be freed */
     1960            rtems_event_send( txDaemonTid, sc->ioevent );
     1961#if 0
    18811962            printk("unit elnk%d tx done\n", sc->xl_unit );
     1963#endif
    18821964         }
    18831965      }
     1966
    18841967
    18851968      if (status & XL_STAT_TX_COMPLETE)
    18861969      {
    18871970         ifp->if_oerrors++;
    1888          printk("etherlink : unit elnk%d transmission error\n", sc->xl_unit );
     1971         {
     1972            unsigned32 txstat;
     1973
     1974            XL_SEL_WIN(1);
     1975            txstat  = CSR_READ_1(sc, XL_W1_TX_STATUS );
     1976            XL_SEL_WIN(7);
     1977           
     1978            printk("etherlink : unit elnk%d transmit error, txstat = %02x \n", sc->xl_unit, txstat );
     1979
     1980            xl_wait(sc);
     1981            CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_TX_DISABLE);
     1982            xl_wait(sc);
     1983            CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_TX_ENABLE);
     1984            xl_wait(sc);
     1985         }
    18891986      }
    18901987      if (status & XL_STAT_ADFAIL)
     
    19522049elnk_initialize_hardware (struct elnk_softc *sc)
    19532050{
    1954    volatile unsigned char *cp;
    1955    int nb, i, rxsize, txsize, ringsize;
     2051   unsigned char *cp;
     2052   int i, j, rxsize, txsize, ringsize;
    19562053
    19572054   /*
    19582055    * Init RX ring
    19592056    */
    1960    cp = (volatile unsigned char *)malloc( (nb =
    1961                                            (ringsize = ((rxsize = (sc->numRxbuffers * sizeof(struct MD))) +
    1962                                                         (txsize = (sc->numTxbuffers * sizeof(struct MD))))) +
    1963                                              (sc->numTxbuffers * XL_PACKET_SIZE)) +
    1964                                           + CPU_CACHE_ALIGNMENT_FOR_BUFFER);
     2057   cp = (unsigned char *)malloc( (ringsize = ((rxsize = (sc->numRxbuffers * sizeof(struct RXMD))) +
     2058                                              (txsize = (sc->numTxbuffers * sizeof(struct TXMD)))) ) +
     2059                                 + CPU_CACHE_ALIGNMENT_FOR_BUFFER);
    19652060   sc->bufferBase = cp;
    19662061   cp += (CPU_CACHE_ALIGNMENT_FOR_BUFFER - (int)cp) & (CPU_CACHE_ALIGNMENT_FOR_BUFFER - 1);
     
    19692064   if (_CPU_is_paging_enabled())
    19702065      _CPU_change_memory_mapping_attribute
    1971          (NULL, cp, nb, PTE_CACHE_DISABLE | PTE_WRITABLE);
     2066         (NULL, cp, ringsize, PTE_CACHE_DISABLE | PTE_WRITABLE);
    19722067#endif
    19732068#endif
    19742069   sc->ringBase = cp;
    19752070
     2071   /* build tx and rx rings */
     2072
     2073   sc->rx_ring = (struct RXMD *)sc->ringBase;
     2074   sc->tx_ring = (struct TXMD *)&sc->ringBase[ rxsize ];
     2075
    19762076   {
    1977       volatile unsigned char *txpackets;
    1978       struct MD            *rx_ring, *tx_ring, *nxtmd, *thismd;
    1979       struct mbuf          *m;
    1980 
    1981       /* rebuild tx and rx rings */
    1982 
    1983       rx_ring = (struct MD *)sc->ringBase;
    1984       tx_ring = (struct MD *)&sc->ringBase[ rxsize ];
    1985       txpackets = &sc->ringBase[ringsize];
    1986 
     2077      struct mbuf    *m;
     2078      struct RXMD    *nxtmd;
    19872079      /*
    1988        * The rx ring is easy as its just an array of MD structs, the mbuf
    1989        * data is dynamically requested from the ip stack.
     2080       * The rx ring is easy as its just an array of RXMD structs.  New
     2081       * mbuf entries are allocated from the stack whenever the rx
     2082       * daemon forwards an incoming packet into it.  Here, we
     2083       * pre-allocate the rx mbufs for the rx ring entries.
    19902084       */
    19912085      for(i=0 ; i<sc->numRxbuffers; i++)
    19922086      {
     2087         if( ((unsigned32)&sc->rx_ring[i] & 0x7) )
     2088         {
     2089            rtems_panic ("etherlink : unit elnk%d rx ring entry %d not aligned to 8 bytes\n", sc->xl_unit, i );
     2090         }
     2091     
    19932092         /* allocate an mbuf for each receive descriptor */
    19942093         MGETHDR (m, M_WAIT, MT_DATA);
    19952094         MCLGET (m, M_WAIT);
    19962095         m->m_pkthdr.rcvif = &sc->arpcom.ac_if;
    1997      
     2096
    19982097         if( i == sc->numRxbuffers-1 )
    1999             nxtmd = &rx_ring[0];
     2098            nxtmd = &sc->rx_ring[0];
    20002099         else
    2001             nxtmd = &rx_ring[i+1];
    2002 
    2003          rx_ring[i].next_md = nxtmd;
    2004          rx_ring[i].mbuf = m;
    2005 
    2006          rx_ring[i].status = 0;
    2007          st_le32( &rx_ring[i].addr, (unsigned32)phys_to_bus( mtod(m, void *) ));
    2008          st_le32( &rx_ring[i].length, XL_LAST_FRAG | XL_PACKET_SIZE );
    2009          st_le32( &rx_ring[i].next, (unsigned32)phys_to_bus( nxtmd ));
     2100            nxtmd = &sc->rx_ring[i+1];
     2101
     2102         sc->rx_ring[i].next_md = nxtmd;
     2103         sc->rx_ring[i].mbuf = m;
     2104
     2105         st_le32( &sc->rx_ring[i].status, 0);
     2106         st_le32( &sc->rx_ring[i].next, (unsigned32)phys_to_bus( nxtmd ));
     2107         st_le32( &sc->rx_ring[i].addr, (unsigned32)phys_to_bus( mtod(m, void *) ));
     2108         st_le32( &sc->rx_ring[i].length, XL_LAST_FRAG | XL_PACKET_SIZE );
    20102109      }
    2011       sc->curr_rx_md = &rx_ring[0];
    2012 
    2013 
     2110      sc->curr_rx_md = &sc->rx_ring[0];
     2111   }
     2112
     2113
     2114   {
     2115      struct TXMD *thismd, *nxtmd;
    20142116      /*
    2015        * The tx ring is more complex. Each MD has a packet buffer
    2016        * permanently assigned to it.  Although the next_md fields form a
    2017        * ring, the DPD next is filled only when packets are added to the
    2018        * tx chain.  mbuf is a scratch register used to form chains of tx
    2019        * packets.
     2117       * The tx ring is more complex. Each MD has an array of fragment
     2118       * descriptors that are loaded from each packet as they arrive
     2119       * from the stack.  Each packet gets one ring entry, this allows
     2120       * the lanboard to efficiently assemble the piecemeal packets into
     2121       * a contiguous unit at transmit time, rather than spending
     2122       * cputime concatenating them first.  Although the next_md fields
     2123       * form a ring, the DPD next is filled only when packets are added
     2124       * to the tx chain, thus last entry of a series of packets has the
     2125       * requisite dpd->next value == 0 to terminate the dma.  mbuf
     2126       * holds the packet info so it can be freed once the packet has
     2127       * been sent.  chainptr is used to link the head & tail of a chain
     2128       * of 2 or more packets.  A chain is formed when the tx daemon
     2129       * gets 2 or more packets from the stack's queue in a service
     2130       * period, so higher outgoing loads are handled as efficiently as
     2131       * possible.
    20202132       */
    20212133
    20222134      for(i=0 ; i<sc->numTxbuffers; i++)
    20232135      {
     2136         if( ((unsigned32)&sc->tx_ring[i] & 0x7) )
     2137         {
     2138            rtems_panic ("etherlink : unit elnk%d tx ring entry %d not aligned to 8 bytes\n", sc->xl_unit, i );
     2139         }
     2140
    20242141         if( i == sc->numTxbuffers-1 )
    2025             nxtmd = &tx_ring[0];
     2142            nxtmd = &sc->tx_ring[0];
    20262143         else
    2027             nxtmd = &tx_ring[i+1];
    2028 
    2029          thismd = &tx_ring[i];
     2144            nxtmd = &sc->tx_ring[i+1];
     2145
     2146         thismd = &sc->tx_ring[i];
    20302147
    20312148         thismd->next_md = nxtmd;
     2149         thismd->chainptr = NULL;
    20322150         thismd->mbuf = NULL;
    20332151
    20342152         st_le32( &thismd->status, XL_TXSTAT_DL_COMPLETE );
    2035          st_le32( &thismd->addr, (unsigned32)phys_to_bus( &txpackets[ i * XL_PACKET_SIZE ] ));
    2036          st_le32( &thismd->length, XL_LAST_FRAG );
    2037          thismd->next = 0;
     2153         st_le32( &thismd->next, 0);
     2154
     2155         for(j=0; j< NUM_FRAGS; j++)
     2156         {
     2157            st_le32( &thismd->txfrags[j].addr, 0 );
     2158            st_le32( &thismd->txfrags[j].length, 0 );
     2159         }
    20382160      }
    2039       sc->last_tx_md = &tx_ring[0];
    2040 
     2161      sc->last_tx_md = &sc->tx_ring[0];
    20412162   }
    20422163
     
    20912212{
    20922213   struct elnk_softc     *sc;
    2093    volatile struct ifnet *ifp;
    20942214   struct ether_header   *eh;
    20952215   struct mbuf           *m;
    2096    volatile struct MD    *rmd;
     2216   struct RXMD           *rmd;
    20972217   unsigned int          i,len, rxstat;
    20982218   rtems_event_set       events;
     
    21592279                        m->m_pkthdr.rcvif = ifp;
    21602280                        rmd->mbuf   = m;
    2161                         rmd->status = 0;
     2281                        st_le32( &rmd->status, 0 );
    21622282                        st_le32( &rmd->addr, (unsigned32)phys_to_bus(mtod(m, void *)) );
    21632283                     }
     
    22102330   struct ifnet          *ifp;
    22112331   struct mbuf           *m;
    2212    struct mbuf           *hold;
    2213    volatile struct MD    *lastmd, *nextmd, *firstmd;
    2214    unsigned char        *pktbuff, *buffer;
    2215    unsigned int         len;
    2216    int                  chainCount,i;
     2332   struct TXMD           *lastmd, *nextmd, *firstmd;
     2333   int                   chainCount,i;
    22172334   rtems_event_set       events;
    22182335
     
    22202337   {
    22212338      /*
    2222        * Wait for packets bound for any of the units
     2339       * Wait for any unit's signal to wake us up
    22232340       */
    22242341      rtems_bsdnet_event_receive( RTEMS_ALL_EVENTS,
     
    22452362               for(;;)
    22462363               {
     2364
     2365                  /*
     2366                  ** Check the chain recovery queue whenever the tx
     2367                  ** daemon wakes up.  Note this routine does not assume
     2368                  ** the context of one of the lanboard units because
     2369                  ** used tx mbufs no longer associated with any unit.
     2370                  */
     2371                  {
     2372                     struct TXMD *chainhead, *chaintail;
     2373                     unsigned32  esize;
     2374
     2375                     if( rtems_message_queue_receive( chainRecoveryQueue, &chainhead, &esize,
     2376                                                      RTEMS_NO_WAIT, 0) == RTEMS_SUCCESSFUL )
     2377                     {
     2378                        /* get a pointer to the tail */
     2379                        chaintail = chainhead->chainptr;
     2380
     2381                        /* if the tail points somewhere, free the entire
     2382                           chain */
     2383                        if( chaintail && (int)chaintail != -1 )
     2384                        {
     2385                           for(;;)
     2386                           {
     2387                              m_freem( chainhead->mbuf );
     2388                              chainhead->mbuf = NULL;
     2389
     2390                              if(  chainhead == chaintail ) break;
     2391                              chainhead = chainhead->next_md;
     2392                           }
     2393                        }
     2394                        else
     2395                        {
     2396                           /* a single packet chain */
     2397                           m_freem( chainhead->mbuf );
     2398                           chainhead->mbuf = NULL;
     2399                        }
     2400                     }
     2401                  }
     2402
     2403
     2404
    22472405                  nextmd = lastmd->next_md;
    22482406
    22492407                  /* stop when ring is full */
    2250                   if( ! (ld_le32(&nextmd->status) & XL_TXSTAT_DL_COMPLETE) )
     2408                  if( nextmd->mbuf || ! (ld_le32(&nextmd->status) & XL_TXSTAT_DL_COMPLETE) )
    22512409                  {
    22522410                     printk("etherlink : unit elnk%d tx ring full!\n", sc->xl_unit);
    22532411                     break;
    22542412                  }
     2413                 
    22552414
    22562415                  IF_DEQUEUE(&ifp->if_snd, m);
    22572416                  if( !m ) break;
    22582417
    2259 
    2260                  
    2261                   hold = m;
    2262                   len = 0;
    2263                  
    2264                   buffer = pktbuff = (char *)bus_to_phys( ld_le32(&nextmd->addr) );
    2265                   for(;;)
    22662418                  {
    2267                      len += m->m_len;
    2268                      memcpy((void*) buffer, (char *)m->m_data, m->m_len);
    2269                      buffer += m->m_len ;
    2270                      if ((m = m->m_next) == NULL)
    2271                         break;
     2419                     int i;
     2420
     2421                     nextmd->mbuf = m;
     2422
     2423                     for(i=0; i< NUM_FRAGS; i++)
     2424                     {
     2425                        st_le32( &nextmd->txfrags[i].length, ((m->m_next)?0:XL_LAST_FRAG) | ( m->m_len & XL_TXSTAT_LENMASK) );
     2426                        st_le32( &nextmd->txfrags[i].addr, (unsigned32)phys_to_bus(m->m_data) );
     2427                        if ((m = m->m_next) == NULL)
     2428                           break;
     2429                     }
     2430                     if( m )
     2431                     {
     2432                        printk("etherlink : unit elnk%d tx fragments exhausted, truncating packet!\n", sc->xl_unit);
     2433                        st_le32( &nextmd->txfrags[NUM_FRAGS-1].length, XL_LAST_FRAG |
     2434                                 ld_le32( &nextmd->txfrags[NUM_FRAGS-1].length) );
     2435                     }
    22722436                  }
    2273                   m_freem( hold );
    2274 
    2275 
     2437
     2438#if 0
    22762439                  {
    2277                      char *pkt = pktbuff, *delim;
     2440                     char *pkt = bus_to_phys( ld_le32( &nextmd->txfrags[i].addr ), *delim;
    22782441                     int  i;
    2279                      printk("unit %i queued  pkt (%08x) ", sc->xl_unit, (unsigned32)pkt );
    2280                      for(delim="", i=0; i < sizeof(struct ether_header)+8; i++, delim=":")
     2442                     printk("unit %d queued  pkt (%08x) ", sc->xl_unit, (unsigned32)pkt );
     2443                     for(delim="", i=0; i < sizeof(struct ether_header); i++, delim=":")
    22812444                        printk("%s%02x", delim, (char) pkt[i] );
    22822445                     printk("\n");
    22832446                  }
    2284 
    2285      
    2286                   if (len < XL_MIN_FRAMELEN ) len = XL_MIN_FRAMELEN;
    2287                   st_le32( &nextmd->length, XL_LAST_FRAG | (len & XL_TXSTAT_LENMASK) );
     2447#endif
     2448
    22882449
    22892450                  /* this packet will be the new end of the list */
    2290                   nextmd->next = 0;
    2291                   nextmd->status = 0;
     2451                  st_le32( &nextmd->next, 0);
     2452                  st_le32( &nextmd->status, 0);
    22922453
    22932454                  if( !firstmd )
     
    22962457                     firstmd = nextmd;
    22972458
    2298                      /* use the mbuf pointer of the last packet of the
    2299                       * previous chain as a flag so when a dnComplete
    2300                       * interrupt indicates the card is finished, the
    2301                       * isr can immediately start the next chain.  Note
    2302                       * several chains of packets may be assembled this
    2303                       * way- but this assignment won't have any effect
    2304                       * if a chain isn't already being transmitted.
     2459                     /*
     2460                      ** use the chainbuf pointer of the last packet of
     2461                      ** the previous chain as a flag so when a
     2462                      ** dnComplete interrupt indicates the card is
     2463                      ** finished downloading the chain, the isr can
     2464                      ** immediately start the next which always begins
     2465                      ** with the next packet in the ring.  Note several
     2466                      ** chains of packets may be assembled this way.
    23052467                      */
    2306                      lastmd->mbuf = (struct mbuf *)-1;
     2468                     lastmd->chainptr = (struct TXMD *)-1;
    23072469                  }
    23082470                  else
     
    23202482               if( firstmd )
    23212483               {
     2484                  /* only entered if we've queued one or more packets */
     2485
    23222486                  /* save the last descriptor we set up in the chain */
    23232487                  sc->last_tx_md = lastmd;
     
    23282492                   * when the card finishes accepting the chain
    23292493                   */
    2330                   st_le32(&lastmd->status, XL_TXSTAT_DL_INTR );
     2494                  st_le32( &lastmd->status, XL_TXSTAT_DL_INTR );
    23312495
    23322496                  /*
     
    23342498                   * locate the next chain to send inside the isr.  If
    23352499                   * we're only sending one packet, then don't bother
    2336                    * with the link, as the mbuf value will either be 0
     2500                   * with the link, as the chainptr value will either be 0
    23372501                   * if theres no next chain or -1 if there is.
    23382502                   */
    23392503                  if( chainCount > 1 )
    2340                      firstmd->mbuf = (struct mbuf *)lastmd;
    2341 
    2342                   /* clear our "next chain present" flag.  If another
    2343                    * chain is added later, this flag will be set to -1
    2344                    */
    2345                   lastmd->mbuf = NULL;
    2346 
     2504                  {
     2505                     firstmd->chainptr = lastmd;
     2506
     2507                     sc->chain_lengths[sc->chlenIndex]= (short)chainCount;
     2508                     if( ++sc->chlenIndex == NUM_CHAIN_LENGTHS ) sc->chlenIndex = 0;
     2509                  }
     2510
     2511                  /*
     2512                  ** clear the last packet's chainptr flag.  If another
     2513                  ** chain is added later, before this chain is finished
     2514                  ** being sent, the flag on this packet will be re-set
     2515                  ** to -1
     2516                  */
     2517                  lastmd->chainptr = NULL;
     2518
     2519#if 0
     2520                  printk("unit %d queued %d pkts, lastpkt status %08X\n",
     2521                         sc->xl_unit,
     2522                         chainCount,
     2523                         (unsigned32)ld_le32( &lastmd->status) );
     2524#endif
    23472525
    23482526                  if( sc->tx_idle == 0 && CSR_READ_4(sc, XL_DOWNLIST_PTR) == 0 )
     
    23522530                  }
    23532531
    2354                   /* start sending this chain of packets if tx isn't busy */
     2532                  /*
     2533                  ** start sending this chain of packets if tx isn't
     2534                  ** busy, else the dnComplete interrupt will see there
     2535                  ** is another chain waiting and begin it immediately.
     2536                  */
    23552537                  if( sc->tx_idle )
    23562538                  {
     2539#if 0
     2540                     printk("etherlink : unit elnk%d tx started %d packets\n", sc->xl_unit, chainCount );
     2541#endif
    23572542                     elnk_start_txchain(sc, firstmd);
    23582543                  }
     
    24112596   struct ifnet *ifp = &sc->arpcom.ac_if;
    24122597
    2413    xl_stop(sc);
    2414 
    2415    XL_SEL_WIN(3);
    2416    CSR_WRITE_1(sc, XL_W3_MAC_CTRL, XL_MACCTRL_DUPLEX);
    2417 
     2598   if( !(ifp->if_flags & IFF_RUNNING) )
    24182599   {
    2419       unsigned32 cr,sr;
    2420 
    2421       xl_miibus_writereg(sc, 0x18, MII_BMCR, BMCR_RESET );
     2600      xl_stop(sc);
     2601      xl_reset(sc);
     2602      sc->tx_idle = -1;
     2603
     2604      {
     2605         unsigned32 cr,sr;
     2606
     2607         xl_miibus_writereg(sc, 0x18, MII_BMCR, BMCR_RESET );
    24222608   
    2423       while( (cr = xl_miibus_readreg(sc, 0x18, MII_BMCR )) & BMCR_RESET )
     2609         while( (cr = xl_miibus_readreg(sc, 0x18, MII_BMCR )) & BMCR_RESET )
     2610         {
     2611            DELAY(100000);
     2612         }
     2613
     2614         xl_miibus_writereg(sc, 0x18, MII_ANAR, ANAR_10 | ANAR_TX | ANAR_10_FD | ANAR_TX_FD );  /*  ANAR_T4 */
     2615         xl_miibus_writereg(sc, 0x18, MII_BMCR, BMCR_STARTNEG | BMCR_AUTOEN );
     2616
     2617         while( ((sr = xl_miibus_readreg(sc, 0x18, MII_BMSR)) & BMSR_ACOMP) == 0 );
     2618      }
     2619
     2620
     2621      /*
     2622       * Set up hardware if its not already been done
     2623       */
     2624      if( !sc->irqInfo.hdl )
    24242625      {
    2425          DELAY(100000);
     2626         elnk_initialize_hardware(sc);
    24262627      }
    24272628
    2428       xl_miibus_writereg(sc, 0x18, MII_ANAR, ANAR_10 | ANAR_10_FD | ANAR_TX | ANAR_TX_FD | ANAR_T4);
    2429       xl_miibus_writereg(sc, 0x18, MII_BMCR, BMCR_AUTOEN );
    2430 
    2431       /* while( ((sr = xl_miibus_readreg(sc, 0x18, MII_BMSR)) & BMSR_ACOMP) == 0 ); */
    2432    }
    2433 
    2434    
    2435    XL_SEL_WIN(7);
    2436    CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_RESET);
    2437    xl_wait(sc);
    2438    CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_TX_RESET);
    2439    xl_wait(sc);
    2440    DELAY(10000);
    2441 
    2442    sc->tx_idle = -1;
    2443 
    2444    /*
    2445     * Set up hardware if its not already been done
    2446     */
    2447    if( !sc->irqInfo.hdl )
    2448    {
    2449       elnk_initialize_hardware(sc);
    2450    }
    2451 
    2452    /*
    2453     * Enable the card
    2454     */
    2455    {
    2456       u_int8_t          rxfilt;
    2457 
    24582629      /*
    2459        * Cancel pending I/O
     2630       * Enable the card
    24602631       */
    2461 
    2462       /* Init our MAC address */
    2463       XL_SEL_WIN(2);
    2464       for (i = 0; i < ETHER_ADDR_LEN; i++)
    24652632      {
    2466          CSR_WRITE_1(sc, XL_W2_STATION_ADDR_LO + i, sc->arpcom.ac_enaddr[i]);
     2633         u_int8_t               rxfilt;
     2634
     2635         /* Init our MAC address */
     2636         XL_SEL_WIN(2);
     2637         for (i = 0; i < ETHER_ADDR_LEN; i++)
     2638         {
     2639            CSR_WRITE_1(sc, XL_W2_STATION_ADDR_LO + i, sc->arpcom.ac_enaddr[i]);
     2640         }
     2641
     2642         {
     2643            int  media = IFM_ETHER|IFM_100_TX|IFM_FDX;
     2644
     2645            xl_mediacheck(sc);
     2646
     2647            /* Choose a default media. */
     2648            switch(sc->xl_xcvr) {
     2649               case XL_XCVR_10BT:
     2650                  media = IFM_ETHER|IFM_10_T;
     2651                  xl_setmode(sc, media);
     2652                  break;
     2653               case XL_XCVR_AUI:
     2654                  if (sc->xl_type == XL_TYPE_905B &&
     2655                      sc->xl_media == XL_MEDIAOPT_10FL) {
     2656                     media = IFM_ETHER|IFM_10_FL;
     2657                     xl_setmode(sc, media);
     2658                  } else {
     2659                     media = IFM_ETHER|IFM_10_5;
     2660                     xl_setmode(sc, media);
     2661                  }
     2662                  break;
     2663               case XL_XCVR_COAX:
     2664                  media = IFM_ETHER|IFM_10_2;
     2665                  xl_setmode(sc, media);
     2666                  break;
     2667               case XL_XCVR_AUTO:
     2668               case XL_XCVR_100BTX:
     2669                  xl_setcfg(sc);
     2670                  break;
     2671               case XL_XCVR_MII:
     2672                  printk("etherlink : unit elnk%d MII media not supported!\n", sc->xl_unit);
     2673                  break;
     2674               case XL_XCVR_100BFX:
     2675                  media = IFM_ETHER|IFM_100_FX;
     2676                  break;
     2677               default:
     2678                  printk("etherlink : unit elnk%d unknown XCVR type: %d\n", sc->xl_unit, sc->xl_xcvr);
     2679                  /*
     2680                   * This will probably be wrong, but it prevents
     2681                   * the ifmedia code from panicking.
     2682                   */
     2683                  media = IFM_ETHER|IFM_10_T;
     2684                  break;
     2685            }
     2686
     2687
     2688            if (sc->xl_flags & XL_FLAG_NO_XCVR_PWR) {
     2689               XL_SEL_WIN(0);
     2690               CSR_WRITE_2(sc, XL_W0_MFG_ID, XL_NO_XCVR_PWR_MAGICBITS);
     2691            }
     2692         }
     2693
     2694
     2695
     2696         XL_SEL_WIN(2);
     2697         /* Clear the station mask. */
     2698         for (i = 0; i < 3; i++)
     2699            CSR_WRITE_2(sc, XL_W2_STATION_MASK_LO + (i * 2), 0);
     2700
     2701         /*
     2702          * Set the TX freethresh value.
     2703          * Note that this has no effect on 3c905B "cyclone"
     2704          * cards but is required for 3c900/3c905 "boomerang"
     2705          * cards in order to enable the download engine.
     2706          */
     2707         CSR_WRITE_1(sc, XL_TX_FREETHRESH, XL_PACKET_SIZE >> 8);
     2708
     2709         /* Set the TX start threshold for best performance. */
     2710         sc->xl_tx_thresh = XL_MIN_FRAMELEN;
     2711         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_TX_SET_START|sc->xl_tx_thresh);
     2712
     2713         /*
     2714          * If this is a 3c905B, also set the tx reclaim threshold.
     2715          * This helps cut down on the number of tx reclaim errors
     2716          * that could happen on a busy network. The chip multiplies
     2717          * the register value by 16 to obtain the actual threshold
     2718          * in bytes, so we divide by 16 when setting the value here.
     2719          * The existing threshold value can be examined by reading
     2720          * the register at offset 9 in window 5.
     2721          */
     2722         if (sc->xl_type == XL_TYPE_905B) {
     2723            CSR_WRITE_2(sc, XL_COMMAND,
     2724                        XL_CMD_SET_TX_RECLAIM|(XL_PACKET_SIZE >> 4));
     2725         }
     2726
     2727         /* Set RX filter bits. */
     2728         XL_SEL_WIN(5);
     2729         rxfilt = CSR_READ_1(sc, XL_W5_RX_FILTER);
     2730
     2731         /* Set the individual bit to receive frames for this host only. */
     2732         rxfilt |= XL_RXFILTER_INDIVIDUAL;
     2733
     2734         /* If we want promiscuous mode, set the allframes bit. */
     2735         if (ifp->if_flags & IFF_PROMISC) {
     2736            rxfilt |= XL_RXFILTER_ALLFRAMES;
     2737            CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_FILT|rxfilt);
     2738         } else {
     2739            rxfilt &= ~XL_RXFILTER_ALLFRAMES;
     2740            CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_FILT|rxfilt);
     2741         }
     2742
     2743         /*
     2744          * Set capture broadcast bit to capture broadcast frames.
     2745          */
     2746         if (ifp->if_flags & IFF_BROADCAST) {
     2747            rxfilt |= XL_RXFILTER_BROADCAST;
     2748            CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_FILT|rxfilt);
     2749         } else {
     2750            rxfilt &= ~XL_RXFILTER_BROADCAST;
     2751            CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_FILT|rxfilt);
     2752         }
     2753
     2754#if 0
     2755         /*
     2756          * Program the multicast filter, if necessary.
     2757          */
     2758         if (sc->xl_type == XL_TYPE_905B)
     2759            xl_setmulti_hash(sc);
     2760         else
     2761            xl_setmulti(sc);
     2762#endif
     2763         /*
     2764          * Load the address of the RX list. We have to
     2765          * stall the upload engine before we can manipulate
     2766          * the uplist pointer register, then unstall it when
     2767          * we're finished. We also have to wait for the
     2768          * stall command to complete before proceeding.
     2769          * Note that we have to do this after any RX resets
     2770          * have completed since the uplist register is cleared
     2771          * by a reset.
     2772          */
     2773         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_UP_STALL);
     2774         xl_wait(sc);
     2775         CSR_WRITE_4(sc, XL_UPLIST_PTR, phys_to_bus( sc->curr_rx_md ));
     2776         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_UP_UNSTALL);
     2777         xl_wait(sc);
     2778
     2779
     2780#if 0
     2781         if (sc->xl_type == XL_TYPE_905B) {
     2782            /* Set polling interval */
     2783            CSR_WRITE_1(sc, XL_DOWN_POLL, 64);
     2784            xl_wait(sc);
     2785            printk("etherlink : unit elnk%d tx polling enabled\n", sc->xl_unit );
     2786         }
     2787#endif
     2788
     2789         /*
     2790          * If the coax transceiver is on, make sure to enable
     2791          * the DC-DC converter.
     2792          */
     2793         XL_SEL_WIN(3);
     2794         if (sc->xl_xcvr == XL_XCVR_COAX)
     2795            CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_COAX_START);
     2796         else
     2797            CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_COAX_STOP);
     2798
     2799         /* increase packet size to allow reception of 802.1q or ISL packets */
     2800         if (sc->xl_type == XL_TYPE_905B)
     2801            CSR_WRITE_2(sc, XL_W3_MAXPKTSIZE, XL_PACKET_SIZE);
     2802         /* Clear out the stats counters. */
     2803
     2804         memset( &sc->xl_stats, 0, sizeof(struct xl_stats));
     2805
     2806         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_STATS_DISABLE);
     2807         sc->xl_stats_no_timeout = 1;
     2808         xl_stats_update(sc->stat_timer_id,sc);
     2809         sc->xl_stats_no_timeout = 0;
     2810         XL_SEL_WIN(4);
     2811         CSR_WRITE_2(sc, XL_W4_NET_DIAG, XL_NETDIAG_UPPER_BYTES_ENABLE);
     2812         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_STATS_ENABLE);
     2813
     2814
     2815         /*
     2816          * Enable interrupts.
     2817          */
     2818         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_INTR_ACK|0xFF);
     2819         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_STAT_ENB|XL_INTRS);
     2820         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_INTR_ENB|XL_INTRS);
     2821
     2822         /* Set the RX early threshold */
     2823         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_THRESH|(XL_PACKET_SIZE >>2));
     2824         CSR_WRITE_4(sc, XL_DMACTL, XL_DMACTL_UP_RX_EARLY );
     2825
     2826         /* Enable receiver and transmitter. */
     2827         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_TX_ENABLE);
     2828         xl_wait(sc);
     2829         CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_ENABLE);
     2830         xl_wait(sc);
     2831
     2832         /* Select window 7 for normal operations. */
     2833         XL_SEL_WIN(7);
     2834
     2835         /* schedule the stats update timer */
     2836         rtems_timer_fire_after( sc->stat_timer_id, sc->stats_update_ticks, xl_stats_update, (void *)sc );
    24672837      }
    24682838
    2469       /* Clear the station mask. */
    2470       for (i = 0; i < 3; i++)
    2471          CSR_WRITE_2(sc, XL_W2_STATION_MASK_LO + (i * 2), 0);
    2472 
    24732839      /*
    2474        * Set the TX freethresh value.
    2475        * Note that this has no effect on 3c905B "cyclone"
    2476        * cards but is required for 3c900/3c905 "boomerang"
    2477        * cards in order to enable the download engine.
     2840       * Tell the world that we're running.
    24782841       */
    2479       CSR_WRITE_1(sc, XL_TX_FREETHRESH, XL_PACKET_SIZE >> 8);
    2480 
    2481       /* Set the TX start threshold for best performance. */
    2482       sc->xl_tx_thresh = XL_MIN_FRAMELEN;
    2483       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_TX_SET_START|sc->xl_tx_thresh);
    2484 
    2485       /*
    2486        * If this is a 3c905B, also set the tx reclaim threshold.
    2487        * This helps cut down on the number of tx reclaim errors
    2488        * that could happen on a busy network. The chip multiplies
    2489        * the register value by 16 to obtain the actual threshold
    2490        * in bytes, so we divide by 16 when setting the value here.
    2491        * The existing threshold value can be examined by reading
    2492        * the register at offset 9 in window 5.
    2493        */
    2494       if (sc->xl_type == XL_TYPE_905B) {
    2495          CSR_WRITE_2(sc, XL_COMMAND,
    2496                      XL_CMD_SET_TX_RECLAIM|(XL_PACKET_SIZE >> 4));
    2497       }
    2498 
    2499       /* Set RX filter bits. */
    2500       XL_SEL_WIN(5);
    2501       rxfilt = CSR_READ_1(sc, XL_W5_RX_FILTER);
    2502 
    2503       /* Set the individual bit to receive frames for this host only. */
    2504       rxfilt |= XL_RXFILTER_INDIVIDUAL;
    2505 
    2506       /* If we want promiscuous mode, set the allframes bit. */
    2507       if (ifp->if_flags & IFF_PROMISC) {
    2508          rxfilt |= XL_RXFILTER_ALLFRAMES;
    2509          CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_FILT|rxfilt);
    2510       } else {
    2511          rxfilt &= ~XL_RXFILTER_ALLFRAMES;
    2512          CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_FILT|rxfilt);
    2513       }
    2514 
    2515       /*
    2516        * Set capture broadcast bit to capture broadcast frames.
    2517        */
    2518       if (ifp->if_flags & IFF_BROADCAST) {
    2519          rxfilt |= XL_RXFILTER_BROADCAST;
    2520          CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_FILT|rxfilt);
    2521       } else {
    2522          rxfilt &= ~XL_RXFILTER_BROADCAST;
    2523          CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_FILT|rxfilt);
    2524       }
    2525 
    2526 #if 0
    2527       /*
    2528        * Program the multicast filter, if necessary.
    2529        */
    2530       if (sc->xl_type == XL_TYPE_905B)
    2531          xl_setmulti_hash(sc);
    2532       else
    2533          xl_setmulti(sc);
    2534 #endif
    2535       /*
    2536        * Load the address of the RX list. We have to
    2537        * stall the upload engine before we can manipulate
    2538        * the uplist pointer register, then unstall it when
    2539        * we're finished. We also have to wait for the
    2540        * stall command to complete before proceeding.
    2541        * Note that we have to do this after any RX resets
    2542        * have completed since the uplist register is cleared
    2543        * by a reset.
    2544        */
    2545       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_UP_STALL);
    2546       xl_wait(sc);
    2547       CSR_WRITE_4(sc, XL_UPLIST_PTR, phys_to_bus( sc->curr_rx_md ));
    2548       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_UP_UNSTALL);
    2549       xl_wait(sc);
    2550 
    2551 
    2552       if (sc->xl_type == XL_TYPE_905B) {
    2553          /* Set polling interval */
    2554          CSR_WRITE_1(sc, XL_DOWN_POLL, 64);
    2555          xl_wait(sc);
    2556       }
    2557 
    2558       /*
    2559        * If the coax transceiver is on, make sure to enable
    2560        * the DC-DC converter.
    2561        */
    2562       XL_SEL_WIN(3);
    2563       if (sc->xl_xcvr == XL_XCVR_COAX)
    2564          CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_COAX_START);
    2565       else
    2566          CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_COAX_STOP);
    2567 
    2568       /* increase packet size to allow reception of 802.1q or ISL packets */
    2569       if (sc->xl_type == XL_TYPE_905B)
    2570          CSR_WRITE_2(sc, XL_W3_MAXPKTSIZE, XL_PACKET_SIZE);
    2571       /* Clear out the stats counters. */
    2572 
    2573       memset( &sc->xl_stats, 0, sizeof(struct xl_stats));
    2574 
    2575       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_STATS_DISABLE);
    2576       sc->xl_stats_no_timeout = 1;
    2577       xl_stats_update(sc->stat_timer_id,sc);
    2578       sc->xl_stats_no_timeout = 0;
    2579       XL_SEL_WIN(4);
    2580       CSR_WRITE_2(sc, XL_W4_NET_DIAG, XL_NETDIAG_UPPER_BYTES_ENABLE);
    2581       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_STATS_ENABLE);
    2582 
    2583 
    2584       /*
    2585        * Enable interrupts.
    2586        */
    2587       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_INTR_ACK|0xFF);
    2588       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_STAT_ENB|XL_INTRS);
    2589       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_INTR_ENB|XL_INTRS);
    2590 
    2591       /* Set the RX early threshold */
    2592       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_THRESH|(XL_PACKET_SIZE >>2));
    2593       CSR_WRITE_2(sc, XL_DMACTL, XL_DMACTL_UP_RX_EARLY );
    2594 
    2595 #if 0
    2596       {
    2597          unsigned32 icfg;
    2598          unsigned16 mctl;
    2599 
    2600          XL_SEL_WIN(3);
    2601          icfg = CSR_READ_4( sc, XL_W3_INTERNAL_CFG );
    2602          mctl = CSR_READ_2( sc, XL_W3_MAC_CTRL );
    2603 
    2604          printk("etherlink : unit elnk%d intcfg %08x, macctl %04x\n", sc->xl_unit, icfg, mctl);
    2605       }
    2606 #endif
    2607 
    2608       /* Enable receiver and transmitter. */
    2609       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_TX_ENABLE);
    2610       xl_wait(sc);
    2611       CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_ENABLE);
    2612       xl_wait(sc);
    2613 
    2614       /* Select window 7 for normal operations. */
    2615       XL_SEL_WIN(7);
    2616 
    2617       /* schedule the stats update timer */
    2618       rtems_timer_fire_after( sc->stat_timer_id, sc->stats_update_ticks, xl_stats_update, (void *)sc );
    2619    }
    2620 
    2621    /*
    2622     * Tell the world that we're running.
    2623     */
    2624    ifp->if_flags |= IFF_RUNNING;
     2842      ifp->if_flags |= IFF_RUNNING;
     2843   }
    26252844}
    26262845
     
    26382857{
    26392858   struct ifnet *ifp = &sc->arpcom.ac_if;
     2859   int i;
    26402860
    26412861   /*
     
    26432863    */
    26442864   xl_stop(sc);
     2865   xl_reset(sc);
     2866   sc->tx_idle = -1;
    26452867
    26462868   ifp->if_flags &= ~IFF_RUNNING;
     2869
     2870   /*
     2871   ** Clear out the rx & tx rings
     2872   */
     2873   {
     2874      struct TXMD *chainhead;
     2875      unsigned32  esize;
     2876
     2877      while( rtems_message_queue_receive( chainRecoveryQueue, &chainhead, &esize,
     2878                                          RTEMS_NO_WAIT, 0) == RTEMS_SUCCESSFUL );
     2879   }
     2880
     2881   for(i=0 ; i<sc->numRxbuffers; i++)
     2882   {
     2883      st_le32( &sc->rx_ring[i].status, 0);
     2884      st_le32( &sc->rx_ring[i].length, XL_LAST_FRAG | XL_PACKET_SIZE );
     2885   }
     2886
     2887   for(i=0 ; i<sc->numTxbuffers; i++)
     2888   {
     2889      st_le32( &sc->tx_ring[i].status, XL_TXSTAT_DL_COMPLETE );
     2890      st_le32( &sc->tx_ring[i].next, 0);
     2891      if( sc->tx_ring[i].mbuf )
     2892      {
     2893         m_free( sc->tx_ring[i].mbuf );
     2894         sc->tx_ring[i].mbuf = NULL;
     2895      }
     2896   }
    26472897}
    26482898
     
    26572907{
    26582908   printf("    MII PHY data { anr:%04x  lpar:%04x  stat:%04x  ctl:%04x }\n",
    2659           sc->xl_unit,
    26602909          sc->xl_stats.miianr,
    26612910          sc->xl_stats.miipar,
     
    26632912          sc->xl_stats.miicmd);
    26642913
    2665    printf("          interrupts:%-5d            intstatus:%04x   mediastat:%04x\n",
    2666           sc->xl_stats.device_interrupts,
    2667           sc->xl_stats.intstatus,
    2668           sc->xl_stats.mediastatus);
     2914   printf("         internalcfg:%08x            macctl:%04x      dmactl:%08x\n",
     2915          sc->xl_stats.internalconfig,
     2916          sc->xl_stats.mac_control,
     2917          sc->xl_stats.dmactl);
    26692918
    26702919   printf("            rxstatus:%04x              txstatus:%02x       smbstat:%04x\n",
     
    26732922          sc->xl_stats.smbstatus);
    26742923
     2924   printf("              txfree:%04X             intstatus:%04x   mediastat:%04x\n",
     2925          sc->xl_stats.txfree,
     2926          sc->xl_stats.intstatus,
     2927          sc->xl_stats.mediastatus);
     2928
     2929
     2930   {
     2931      int       i, totalLengths= 0, numLengths= 0;
     2932
     2933      for(i=0; i< NUM_CHAIN_LENGTHS; i++)
     2934      {
     2935         if( sc->chain_lengths[i] > -1 )
     2936         {
     2937            totalLengths += sc->chain_lengths[i];
     2938            ++numLengths;
     2939         }
     2940      }
     2941
     2942      printf("          interrupts:%-9d    avg_chain_len:%-5d\n",
     2943             sc->xl_stats.device_interrupts,
     2944             (totalLengths / numLengths) );
     2945   }
     2946
    26752947   printf("        carrier_lost:%-5d             sqe_errs:%-5d\n",   
    26762948          sc->xl_stats.xl_carrier_lost,
     
    26892961          sc->xl_stats.xl_badssd);
    26902962
    2691    printf("        rx_frames_ok:%-5d         tx_frames_ok:%-5d\n",   
    2692           sc->xl_stats.xl_rx_frames_ok + ((sc->xl_stats.xl_upper_frames_ok & 3) << 16),
    2693           sc->xl_stats.xl_tx_frames_ok + (((sc->xl_stats.xl_upper_frames_ok >> 4) & 3) << 16) );
    2694 
    2695    printf("         rx_bytes_ok:%-5d          tx_bytes_ok:%-5d\n",   
    2696           sc->xl_stats.xl_rx_bytes_ok + ((sc->xl_stats.xl_upper_bytes_ok & 7) << 16),
    2697           sc->xl_stats.xl_tx_bytes_ok + (((sc->xl_stats.xl_upper_bytes_ok >> 4) & 7) << 16) );
     2963   printf("        rx_frames_ok:%-9d     tx_frames_ok:%-9d\n",   
     2964          sc->xl_stats.xl_rx_frames_ok,
     2965          sc->xl_stats.xl_tx_frames_ok);
     2966
     2967   printf("         rx_bytes_ok:%-9d      tx_bytes_ok:%-9d\n",   
     2968          sc->xl_stats.xl_rx_bytes_ok,
     2969          sc->xl_stats.xl_tx_bytes_ok );
    26982970}
    26992971
     
    29373209   sc->numTxbuffers = (config->xbuf_count) ? config->xbuf_count : TX_RING_SIZE;
    29383210
     3211
     3212   for(i=0; i< NUM_CHAIN_LENGTHS; i++) sc->chain_lengths[i]= -1;
     3213   sc->chlenIndex = 0;
     3214
     3215
    29393216   if (config->mtu)
    29403217      mtu = config->mtu;
     
    29843261                                       PCI_COMMAND_MASTER |
    29853262                                       PCI_COMMAND_INVALIDATE |
    2986                                        PCI_COMMAND_WAIT |
    2987                                        PCI_COMMAND_FAST_BACK ) );
     3263                                       PCI_COMMAND_WAIT ) );
    29883264
    29893265   /*
     
    30143290   */
    30153291
    3016 #if 0
    30173292   {
    30183293      unsigned8 pci_latency;
     
    30303305      }
    30313306   }
    3032 #endif
    3033 
    30343307
    30353308   /* Reset the adapter. */
     
    30403313      u_int16_t         xcvr[2];
    30413314      u_char            eaddr[ETHER_ADDR_LEN];
    3042       int               media = IFM_ETHER|IFM_100_TX|IFM_FDX;
    30433315
    30443316      sc->xl_flags = 0;
     
    31503422      }
    31513423                   
    3152       xl_mediacheck(sc);
    3153 
    3154 #if 0
    3155 /* this has already been called by xl_mediacheck()- hopefully
    3156    I've not messed something up here */
    3157       /*
    3158        * Sanity check. If the user has selected "auto" and this isn't
    3159        * a 10/100 card of some kind, we need to force the transceiver
    3160        * type to something sane.
    3161        */
    3162       if (sc->xl_xcvr == XL_XCVR_AUTO)
    3163          xl_choose_xcvr(sc, 1);
    3164 #endif
    3165 
    3166 
    3167       /* Choose a default media. */
    3168       switch(sc->xl_xcvr) {
    3169          case XL_XCVR_10BT:
    3170             media = IFM_ETHER|IFM_10_T;
    3171             xl_setmode(sc, media);
    3172             break;
    3173          case XL_XCVR_AUI:
    3174             if (sc->xl_type == XL_TYPE_905B &&
    3175                 sc->xl_media == XL_MEDIAOPT_10FL) {
    3176                media = IFM_ETHER|IFM_10_FL;
    3177                xl_setmode(sc, media);
    3178             } else {
    3179                media = IFM_ETHER|IFM_10_5;
    3180                xl_setmode(sc, media);
    3181             }
    3182             break;
    3183          case XL_XCVR_COAX:
    3184             media = IFM_ETHER|IFM_10_2;
    3185             xl_setmode(sc, media);
    3186             break;
    3187          case XL_XCVR_AUTO:
    3188          case XL_XCVR_100BTX:
    3189             xl_setcfg(sc);
    3190             break;
    3191          case XL_XCVR_MII:
    3192             printk("etherlink : unit elnk%d MII media not supported!\n", sc->xl_unit);
    3193             break;
    3194          case XL_XCVR_100BFX:
    3195             media = IFM_ETHER|IFM_100_FX;
    3196             break;
    3197          default:
    3198             printk("etherlink : unit elnk%d unknown XCVR type: %d\n", sc->xl_unit, sc->xl_xcvr);
    3199             /*
    3200              * This will probably be wrong, but it prevents
    3201              * the ifmedia code from panicking.
    3202              */
    3203             media = IFM_ETHER|IFM_10_T;
    3204             break;
    3205       }
    3206 
    3207 
    3208       if (sc->xl_flags & XL_FLAG_NO_XCVR_PWR) {
    3209          XL_SEL_WIN(0);
    3210          CSR_WRITE_2(sc, XL_W0_MFG_ID, XL_NO_XCVR_PWR_MAGICBITS);
    3211       }
    3212 
    32133424      XL_SEL_WIN(7);
    32143425   }
     
    32503461   if (txDaemonTid == 0)
    32513462   {
     3463      if( rtems_message_queue_create( rtems_build_name('X','L','c','r'),
     3464                                      sc->numTxbuffers+1,
     3465                                      sizeof(struct TXMD *),
     3466                                      RTEMS_FIFO | RTEMS_LOCAL,
     3467                                      &chainRecoveryQueue ) != RTEMS_SUCCESSFUL )
     3468      {
     3469         rtems_panic( "etherlink : Unable to create TX buffer recovery queue\n" );
     3470      }
     3471                                                       
     3472
    32523473      rxDaemonTid = rtems_bsdnet_newproc( "XLrx", 4096,
    32533474                                          elnk_rxDaemon, NULL);
Note: See TracChangeset for help on using the changeset viewer.