ethernet/natsemi/sonic.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * sonic.c
0004  *
0005  * (C) 2005 Finn Thain
0006  *
0007  * Converted to DMA API, added zero-copy buffer handling, and
0008  * (from the mac68k project) introduced dhd's support for 16-bit cards.
0009  *
0010  * (C) 1996,1998 by Thomas Bogendoerfer (tsbogend@alpha.franken.de)
0011  *
0012  * This driver is based on work from Andreas Busse, but most of
0013  * the code is rewritten.
0014  *
0015  * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
0016  *
0017  *    Core code included by system sonic drivers
0018  *
0019  * And... partially rewritten again by David Huggins-Daines in order
0020  * to cope with screwed up Macintosh NICs that may or may not use
0021  * 16-bit DMA.
0022  *
0023  * (C) 1999 David Huggins-Daines <dhd@debian.org>
0024  *
0025  */
0026
0027 /*
0028  * Sources: Olivetti M700-10 Risc Personal Computer hardware handbook,
0029  * National Semiconductors data sheet for the DP83932B Sonic Ethernet
0030  * controller, and the files "8390.c" and "skeleton.c" in this directory.
0031  *
0032  * Additional sources: Nat Semi data sheet for the DP83932C and Nat Semi
0033  * Application Note AN-746, the files "lance.c" and "ibmlana.c". See also
0034  * the NetBSD file "sys/arch/mac68k/dev/if_sn.c".
0035  */
0036
0037 static unsigned int version_printed;
0038
0039 static int sonic_debug = -1;
0040 module_param(sonic_debug, int, 0);
0041 MODULE_PARM_DESC(sonic_debug, "debug message level");
0042
0043 static void sonic_msg_init(struct net_device *dev)
0044 {
0045     struct sonic_local *lp = netdev_priv(dev);
0046
0047     lp->msg_enable = netif_msg_init(sonic_debug, 0);
0048
0049     if (version_printed++ == 0)
0050         netif_dbg(lp, drv, dev, "%s", version);
0051 }
0052
0053 static int sonic_alloc_descriptors(struct net_device *dev)
0054 {
0055     struct sonic_local *lp = netdev_priv(dev);
0056
0057     /* Allocate a chunk of memory for the descriptors. Note that this
0058      * must not cross a 64K boundary. It is smaller than one page which
0059      * means that page alignment is a sufficient condition.
0060      */
0061     lp->descriptors =
0062         dma_alloc_coherent(lp->device,
0063                    SIZEOF_SONIC_DESC *
0064                    SONIC_BUS_SCALE(lp->dma_bitmode),
0065                    &lp->descriptors_laddr, GFP_KERNEL);
0066
0067     if (!lp->descriptors)
0068         return -ENOMEM;
0069
0070     lp->cda = lp->descriptors;
0071     lp->tda = lp->cda + SIZEOF_SONIC_CDA *
0072                 SONIC_BUS_SCALE(lp->dma_bitmode);
0073     lp->rda = lp->tda + SIZEOF_SONIC_TD * SONIC_NUM_TDS *
0074                 SONIC_BUS_SCALE(lp->dma_bitmode);
0075     lp->rra = lp->rda + SIZEOF_SONIC_RD * SONIC_NUM_RDS *
0076                 SONIC_BUS_SCALE(lp->dma_bitmode);
0077
0078     lp->cda_laddr = lp->descriptors_laddr;
0079     lp->tda_laddr = lp->cda_laddr + SIZEOF_SONIC_CDA *
0080                     SONIC_BUS_SCALE(lp->dma_bitmode);
0081     lp->rda_laddr = lp->tda_laddr + SIZEOF_SONIC_TD * SONIC_NUM_TDS *
0082                     SONIC_BUS_SCALE(lp->dma_bitmode);
0083     lp->rra_laddr = lp->rda_laddr + SIZEOF_SONIC_RD * SONIC_NUM_RDS *
0084                     SONIC_BUS_SCALE(lp->dma_bitmode);
0085
0086     return 0;
0087 }
0088
0089 /*
0090  * Open/initialize the SONIC controller.
0091  *
0092  * This routine should set everything up anew at each open, even
0093  *  registers that "should" only need to be set once at boot, so that
0094  *  there is non-reboot way to recover if something goes wrong.
0095  */
0096 static int sonic_open(struct net_device *dev)
0097 {
0098     struct sonic_local *lp = netdev_priv(dev);
0099     int i;
0100
0101     netif_dbg(lp, ifup, dev, "%s: initializing sonic driver\n", __func__);
0102
0103     spin_lock_init(&lp->lock);
0104
0105     for (i = 0; i < SONIC_NUM_RRS; i++) {
0106         struct sk_buff *skb = netdev_alloc_skb(dev, SONIC_RBSIZE + 2);
0107         if (skb == NULL) {
0108             while(i > 0) { /* free any that were allocated successfully */
0109                 i--;
0110                 dev_kfree_skb(lp->rx_skb[i]);
0111                 lp->rx_skb[i] = NULL;
0112             }
0113             printk(KERN_ERR "%s: couldn't allocate receive buffers\n",
0114                    dev->name);
0115             return -ENOMEM;
0116         }
0117         /* align IP header unless DMA requires otherwise */
0118         if (SONIC_BUS_SCALE(lp->dma_bitmode) == 2)
0119             skb_reserve(skb, 2);
0120         lp->rx_skb[i] = skb;
0121     }
0122
0123     for (i = 0; i < SONIC_NUM_RRS; i++) {
0124         dma_addr_t laddr = dma_map_single(lp->device, skb_put(lp->rx_skb[i], SONIC_RBSIZE),
0125                                           SONIC_RBSIZE, DMA_FROM_DEVICE);
0126         if (dma_mapping_error(lp->device, laddr)) {
0127             while(i > 0) { /* free any that were mapped successfully */
0128                 i--;
0129                 dma_unmap_single(lp->device, lp->rx_laddr[i], SONIC_RBSIZE, DMA_FROM_DEVICE);
0130                 lp->rx_laddr[i] = (dma_addr_t)0;
0131             }
0132             for (i = 0; i < SONIC_NUM_RRS; i++) {
0133                 dev_kfree_skb(lp->rx_skb[i]);
0134                 lp->rx_skb[i] = NULL;
0135             }
0136             printk(KERN_ERR "%s: couldn't map rx DMA buffers\n",
0137                    dev->name);
0138             return -ENOMEM;
0139         }
0140         lp->rx_laddr[i] = laddr;
0141     }
0142
0143     /*
0144      * Initialize the SONIC
0145      */
0146     sonic_init(dev, true);
0147
0148     netif_start_queue(dev);
0149
0150     netif_dbg(lp, ifup, dev, "%s: Initialization done\n", __func__);
0151
0152     return 0;
0153 }
0154
0155 /* Wait for the SONIC to become idle. */
0156 static void sonic_quiesce(struct net_device *dev, u16 mask, bool may_sleep)
0157 {
0158     struct sonic_local * __maybe_unused lp = netdev_priv(dev);
0159     int i;
0160     u16 bits;
0161
0162     for (i = 0; i < 1000; ++i) {
0163         bits = SONIC_READ(SONIC_CMD) & mask;
0164         if (!bits)
0165             return;
0166         if (!may_sleep)
0167             udelay(20);
0168         else
0169             usleep_range(100, 200);
0170     }
0171     WARN_ONCE(1, "command deadline expired! 0x%04x\n", bits);
0172 }
0173
0174 /*
0175  * Close the SONIC device
0176  */
0177 static int sonic_close(struct net_device *dev)
0178 {
0179     struct sonic_local *lp = netdev_priv(dev);
0180     int i;
0181
0182     netif_dbg(lp, ifdown, dev, "%s\n", __func__);
0183
0184     netif_stop_queue(dev);
0185
0186     /*
0187      * stop the SONIC, disable interrupts
0188      */
0189     SONIC_WRITE(SONIC_CMD, SONIC_CR_RXDIS);
0190     sonic_quiesce(dev, SONIC_CR_ALL, true);
0191
0192     SONIC_WRITE(SONIC_IMR, 0);
0193     SONIC_WRITE(SONIC_ISR, 0x7fff);
0194     SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
0195
0196     /* unmap and free skbs that haven't been transmitted */
0197     for (i = 0; i < SONIC_NUM_TDS; i++) {
0198         if(lp->tx_laddr[i]) {
0199             dma_unmap_single(lp->device, lp->tx_laddr[i], lp->tx_len[i], DMA_TO_DEVICE);
0200             lp->tx_laddr[i] = (dma_addr_t)0;
0201         }
0202         if(lp->tx_skb[i]) {
0203             dev_kfree_skb(lp->tx_skb[i]);
0204             lp->tx_skb[i] = NULL;
0205         }
0206     }
0207
0208     /* unmap and free the receive buffers */
0209     for (i = 0; i < SONIC_NUM_RRS; i++) {
0210         if(lp->rx_laddr[i]) {
0211             dma_unmap_single(lp->device, lp->rx_laddr[i], SONIC_RBSIZE, DMA_FROM_DEVICE);
0212             lp->rx_laddr[i] = (dma_addr_t)0;
0213         }
0214         if(lp->rx_skb[i]) {
0215             dev_kfree_skb(lp->rx_skb[i]);
0216             lp->rx_skb[i] = NULL;
0217         }
0218     }
0219
0220     return 0;
0221 }
0222
0223 static void sonic_tx_timeout(struct net_device *dev, unsigned int txqueue)
0224 {
0225     struct sonic_local *lp = netdev_priv(dev);
0226     int i;
0227     /*
0228      * put the Sonic into software-reset mode and
0229      * disable all interrupts before releasing DMA buffers
0230      */
0231     SONIC_WRITE(SONIC_CMD, SONIC_CR_RXDIS);
0232     sonic_quiesce(dev, SONIC_CR_ALL, false);
0233
0234     SONIC_WRITE(SONIC_IMR, 0);
0235     SONIC_WRITE(SONIC_ISR, 0x7fff);
0236     SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
0237     /* We could resend the original skbs. Easier to re-initialise. */
0238     for (i = 0; i < SONIC_NUM_TDS; i++) {
0239         if(lp->tx_laddr[i]) {
0240             dma_unmap_single(lp->device, lp->tx_laddr[i], lp->tx_len[i], DMA_TO_DEVICE);
0241             lp->tx_laddr[i] = (dma_addr_t)0;
0242         }
0243         if(lp->tx_skb[i]) {
0244             dev_kfree_skb(lp->tx_skb[i]);
0245             lp->tx_skb[i] = NULL;
0246         }
0247     }
0248     /* Try to restart the adaptor. */
0249     sonic_init(dev, false);
0250     lp->stats.tx_errors++;
0251     netif_trans_update(dev); /* prevent tx timeout */
0252     netif_wake_queue(dev);
0253 }
0254
0255 /*
0256  * transmit packet
0257  *
0258  * Appends new TD during transmission thus avoiding any TX interrupts
0259  * until we run out of TDs.
0260  * This routine interacts closely with the ISR in that it may,
0261  *   set tx_skb[i]
0262  *   reset the status flags of the new TD
0263  *   set and reset EOL flags
0264  *   stop the tx queue
0265  * The ISR interacts with this routine in various ways. It may,
0266  *   reset tx_skb[i]
0267  *   test the EOL and status flags of the TDs
0268  *   wake the tx queue
0269  * Concurrently with all of this, the SONIC is potentially writing to
0270  * the status flags of the TDs.
0271  */
0272
0273 static int sonic_send_packet(struct sk_buff *skb, struct net_device *dev)
0274 {
0275     struct sonic_local *lp = netdev_priv(dev);
0276     dma_addr_t laddr;
0277     int length;
0278     int entry;
0279     unsigned long flags;
0280
0281     netif_dbg(lp, tx_queued, dev, "%s: skb=%p\n", __func__, skb);
0282
0283     length = skb->len;
0284     if (length < ETH_ZLEN) {
0285         if (skb_padto(skb, ETH_ZLEN))
0286             return NETDEV_TX_OK;
0287         length = ETH_ZLEN;
0288     }
0289
0290     /*
0291      * Map the packet data into the logical DMA address space
0292      */
0293
0294     laddr = dma_map_single(lp->device, skb->data, length, DMA_TO_DEVICE);
0295     if (!laddr) {
0296         pr_err_ratelimited("%s: failed to map tx DMA buffer.\n", dev->name);
0297         dev_kfree_skb_any(skb);
0298         return NETDEV_TX_OK;
0299     }
0300
0301     spin_lock_irqsave(&lp->lock, flags);
0302
0303     entry = (lp->eol_tx + 1) & SONIC_TDS_MASK;
0304
0305     sonic_tda_put(dev, entry, SONIC_TD_STATUS, 0);       /* clear status */
0306     sonic_tda_put(dev, entry, SONIC_TD_FRAG_COUNT, 1);   /* single fragment */
0307     sonic_tda_put(dev, entry, SONIC_TD_PKTSIZE, length); /* length of packet */
0308     sonic_tda_put(dev, entry, SONIC_TD_FRAG_PTR_L, laddr & 0xffff);
0309     sonic_tda_put(dev, entry, SONIC_TD_FRAG_PTR_H, laddr >> 16);
0310     sonic_tda_put(dev, entry, SONIC_TD_FRAG_SIZE, length);
0311     sonic_tda_put(dev, entry, SONIC_TD_LINK,
0312         sonic_tda_get(dev, entry, SONIC_TD_LINK) | SONIC_EOL);
0313
0314     sonic_tda_put(dev, lp->eol_tx, SONIC_TD_LINK, ~SONIC_EOL &
0315               sonic_tda_get(dev, lp->eol_tx, SONIC_TD_LINK));
0316
0317     netif_dbg(lp, tx_queued, dev, "%s: issuing Tx command\n", __func__);
0318
0319     SONIC_WRITE(SONIC_CMD, SONIC_CR_TXP);
0320
0321     lp->tx_len[entry] = length;
0322     lp->tx_laddr[entry] = laddr;
0323     lp->tx_skb[entry] = skb;
0324
0325     lp->eol_tx = entry;
0326
0327     entry = (entry + 1) & SONIC_TDS_MASK;
0328     if (lp->tx_skb[entry]) {
0329         /* The ring is full, the ISR has yet to process the next TD. */
0330         netif_dbg(lp, tx_queued, dev, "%s: stopping queue\n", __func__);
0331         netif_stop_queue(dev);
0332         /* after this packet, wait for ISR to free up some TDAs */
0333     }
0334
0335     spin_unlock_irqrestore(&lp->lock, flags);
0336
0337     return NETDEV_TX_OK;
0338 }
0339
0340 /*
0341  * The typical workload of the driver:
0342  * Handle the network interface interrupts.
0343  */
0344 static irqreturn_t sonic_interrupt(int irq, void *dev_id)
0345 {
0346     struct net_device *dev = dev_id;
0347     struct sonic_local *lp = netdev_priv(dev);
0348     int status;
0349     unsigned long flags;
0350
0351     /* The lock has two purposes. Firstly, it synchronizes sonic_interrupt()
0352      * with sonic_send_packet() so that the two functions can share state.
0353      * Secondly, it makes sonic_interrupt() re-entrant, as that is required
0354      * by macsonic which must use two IRQs with different priority levels.
0355      */
0356     spin_lock_irqsave(&lp->lock, flags);
0357
0358     status = SONIC_READ(SONIC_ISR) & SONIC_IMR_DEFAULT;
0359     if (!status) {
0360         spin_unlock_irqrestore(&lp->lock, flags);
0361
0362         return IRQ_NONE;
0363     }
0364
0365     do {
0366         SONIC_WRITE(SONIC_ISR, status); /* clear the interrupt(s) */
0367
0368         if (status & SONIC_INT_PKTRX) {
0369             netif_dbg(lp, intr, dev, "%s: packet rx\n", __func__);
0370             sonic_rx(dev);  /* got packet(s) */
0371         }
0372
0373         if (status & SONIC_INT_TXDN) {
0374             int entry = lp->cur_tx;
0375             int td_status;
0376             int freed_some = 0;
0377
0378             /* The state of a Transmit Descriptor may be inferred
0379              * from { tx_skb[entry], td_status } as follows.
0380              * { clear, clear } => the TD has never been used
0381              * { set,   clear } => the TD was handed to SONIC
0382              * { set,   set   } => the TD was handed back
0383              * { clear, set   } => the TD is available for re-use
0384              */
0385
0386             netif_dbg(lp, intr, dev, "%s: tx done\n", __func__);
0387
0388             while (lp->tx_skb[entry] != NULL) {
0389                 if ((td_status = sonic_tda_get(dev, entry, SONIC_TD_STATUS)) == 0)
0390                     break;
0391
0392                 if (td_status & SONIC_TCR_PTX) {
0393                     lp->stats.tx_packets++;
0394                     lp->stats.tx_bytes += sonic_tda_get(dev, entry, SONIC_TD_PKTSIZE);
0395                 } else {
0396                     if (td_status & (SONIC_TCR_EXD |
0397                         SONIC_TCR_EXC | SONIC_TCR_BCM))
0398                         lp->stats.tx_aborted_errors++;
0399                     if (td_status &
0400                         (SONIC_TCR_NCRS | SONIC_TCR_CRLS))
0401                         lp->stats.tx_carrier_errors++;
0402                     if (td_status & SONIC_TCR_OWC)
0403                         lp->stats.tx_window_errors++;
0404                     if (td_status & SONIC_TCR_FU)
0405                         lp->stats.tx_fifo_errors++;
0406                 }
0407
0408                 /* We must free the original skb */
0409                 dev_consume_skb_irq(lp->tx_skb[entry]);
0410                 lp->tx_skb[entry] = NULL;
0411                 /* and unmap DMA buffer */
0412                 dma_unmap_single(lp->device, lp->tx_laddr[entry], lp->tx_len[entry], DMA_TO_DEVICE);
0413                 lp->tx_laddr[entry] = (dma_addr_t)0;
0414                 freed_some = 1;
0415
0416                 if (sonic_tda_get(dev, entry, SONIC_TD_LINK) & SONIC_EOL) {
0417                     entry = (entry + 1) & SONIC_TDS_MASK;
0418                     break;
0419                 }
0420                 entry = (entry + 1) & SONIC_TDS_MASK;
0421             }
0422
0423             if (freed_some || lp->tx_skb[entry] == NULL)
0424                 netif_wake_queue(dev);  /* The ring is no longer full */
0425             lp->cur_tx = entry;
0426         }
0427
0428         /*
0429          * check error conditions
0430          */
0431         if (status & SONIC_INT_RFO) {
0432             netif_dbg(lp, rx_err, dev, "%s: rx fifo overrun\n",
0433                   __func__);
0434         }
0435         if (status & SONIC_INT_RDE) {
0436             netif_dbg(lp, rx_err, dev, "%s: rx descriptors exhausted\n",
0437                   __func__);
0438         }
0439         if (status & SONIC_INT_RBAE) {
0440             netif_dbg(lp, rx_err, dev, "%s: rx buffer area exceeded\n",
0441                   __func__);
0442         }
0443
0444         /* counter overruns; all counters are 16bit wide */
0445         if (status & SONIC_INT_FAE)
0446             lp->stats.rx_frame_errors += 65536;
0447         if (status & SONIC_INT_CRC)
0448             lp->stats.rx_crc_errors += 65536;
0449         if (status & SONIC_INT_MP)
0450             lp->stats.rx_missed_errors += 65536;
0451
0452         /* transmit error */
0453         if (status & SONIC_INT_TXER) {
0454             u16 tcr = SONIC_READ(SONIC_TCR);
0455
0456             netif_dbg(lp, tx_err, dev, "%s: TXER intr, TCR %04x\n",
0457                   __func__, tcr);
0458
0459             if (tcr & (SONIC_TCR_EXD | SONIC_TCR_EXC |
0460                    SONIC_TCR_FU | SONIC_TCR_BCM)) {
0461                 /* Aborted transmission. Try again. */
0462                 netif_stop_queue(dev);
0463                 SONIC_WRITE(SONIC_CMD, SONIC_CR_TXP);
0464             }
0465         }
0466
0467         /* bus retry */
0468         if (status & SONIC_INT_BR) {
0469             printk(KERN_ERR "%s: Bus retry occurred! Device interrupt disabled.\n",
0470                 dev->name);
0471             /* ... to help debug DMA problems causing endless interrupts. */
0472             /* Bounce the eth interface to turn on the interrupt again. */
0473             SONIC_WRITE(SONIC_IMR, 0);
0474         }
0475
0476         status = SONIC_READ(SONIC_ISR) & SONIC_IMR_DEFAULT;
0477     } while (status);
0478
0479     spin_unlock_irqrestore(&lp->lock, flags);
0480
0481     return IRQ_HANDLED;
0482 }
0483
0484 /* Return the array index corresponding to a given Receive Buffer pointer. */
0485 static int index_from_addr(struct sonic_local *lp, dma_addr_t addr,
0486                unsigned int last)
0487 {
0488     unsigned int i = last;
0489
0490     do {
0491         i = (i + 1) & SONIC_RRS_MASK;
0492         if (addr == lp->rx_laddr[i])
0493             return i;
0494     } while (i != last);
0495
0496     return -ENOENT;
0497 }
0498
0499 /* Allocate and map a new skb to be used as a receive buffer. */
0500 static bool sonic_alloc_rb(struct net_device *dev, struct sonic_local *lp,
0501                struct sk_buff **new_skb, dma_addr_t *new_addr)
0502 {
0503     *new_skb = netdev_alloc_skb(dev, SONIC_RBSIZE + 2);
0504     if (!*new_skb)
0505         return false;
0506
0507     if (SONIC_BUS_SCALE(lp->dma_bitmode) == 2)
0508         skb_reserve(*new_skb, 2);
0509
0510     *new_addr = dma_map_single(lp->device, skb_put(*new_skb, SONIC_RBSIZE),
0511                    SONIC_RBSIZE, DMA_FROM_DEVICE);
0512     if (!*new_addr) {
0513         dev_kfree_skb(*new_skb);
0514         *new_skb = NULL;
0515         return false;
0516     }
0517
0518     return true;
0519 }
0520
0521 /* Place a new receive resource in the Receive Resource Area and update RWP. */
0522 static void sonic_update_rra(struct net_device *dev, struct sonic_local *lp,
0523                  dma_addr_t old_addr, dma_addr_t new_addr)
0524 {
0525     unsigned int entry = sonic_rr_entry(dev, SONIC_READ(SONIC_RWP));
0526     unsigned int end = sonic_rr_entry(dev, SONIC_READ(SONIC_RRP));
0527     u32 buf;
0528
0529     /* The resources in the range [RRP, RWP) belong to the SONIC. This loop
0530      * scans the other resources in the RRA, those in the range [RWP, RRP).
0531      */
0532     do {
0533         buf = (sonic_rra_get(dev, entry, SONIC_RR_BUFADR_H) << 16) |
0534               sonic_rra_get(dev, entry, SONIC_RR_BUFADR_L);
0535
0536         if (buf == old_addr)
0537             break;
0538
0539         entry = (entry + 1) & SONIC_RRS_MASK;
0540     } while (entry != end);
0541
0542     WARN_ONCE(buf != old_addr, "failed to find resource!\n");
0543
0544     sonic_rra_put(dev, entry, SONIC_RR_BUFADR_H, new_addr >> 16);
0545     sonic_rra_put(dev, entry, SONIC_RR_BUFADR_L, new_addr & 0xffff);
0546
0547     entry = (entry + 1) & SONIC_RRS_MASK;
0548
0549     SONIC_WRITE(SONIC_RWP, sonic_rr_addr(dev, entry));
0550 }
0551
0552 /*
0553  * We have a good packet(s), pass it/them up the network stack.
0554  */
0555 static void sonic_rx(struct net_device *dev)
0556 {
0557     struct sonic_local *lp = netdev_priv(dev);
0558     int entry = lp->cur_rx;
0559     int prev_entry = lp->eol_rx;
0560     bool rbe = false;
0561
0562     while (sonic_rda_get(dev, entry, SONIC_RD_IN_USE) == 0) {
0563         u16 status = sonic_rda_get(dev, entry, SONIC_RD_STATUS);
0564
0565         /* If the RD has LPKT set, the chip has finished with the RB */
0566         if ((status & SONIC_RCR_PRX) && (status & SONIC_RCR_LPKT)) {
0567             struct sk_buff *new_skb;
0568             dma_addr_t new_laddr;
0569             u32 addr = (sonic_rda_get(dev, entry,
0570                           SONIC_RD_PKTPTR_H) << 16) |
0571                    sonic_rda_get(dev, entry, SONIC_RD_PKTPTR_L);
0572             int i = index_from_addr(lp, addr, entry);
0573
0574             if (i < 0) {
0575                 WARN_ONCE(1, "failed to find buffer!\n");
0576                 break;
0577             }
0578
0579             if (sonic_alloc_rb(dev, lp, &new_skb, &new_laddr)) {
0580                 struct sk_buff *used_skb = lp->rx_skb[i];
0581                 int pkt_len;
0582
0583                 /* Pass the used buffer up the stack */
0584                 dma_unmap_single(lp->device, addr, SONIC_RBSIZE,
0585                          DMA_FROM_DEVICE);
0586
0587                 pkt_len = sonic_rda_get(dev, entry,
0588                             SONIC_RD_PKTLEN);
0589                 skb_trim(used_skb, pkt_len);
0590                 used_skb->protocol = eth_type_trans(used_skb,
0591                                     dev);
0592                 netif_rx(used_skb);
0593                 lp->stats.rx_packets++;
0594                 lp->stats.rx_bytes += pkt_len;
0595
0596                 lp->rx_skb[i] = new_skb;
0597                 lp->rx_laddr[i] = new_laddr;
0598             } else {
0599                 /* Failed to obtain a new buffer so re-use it */
0600                 new_laddr = addr;
0601                 lp->stats.rx_dropped++;
0602             }
0603             /* If RBE is already asserted when RWP advances then
0604              * it's safe to clear RBE after processing this packet.
0605              */
0606             rbe = rbe || SONIC_READ(SONIC_ISR) & SONIC_INT_RBE;
0607             sonic_update_rra(dev, lp, addr, new_laddr);
0608         }
0609         /*
0610          * give back the descriptor
0611          */
0612         sonic_rda_put(dev, entry, SONIC_RD_STATUS, 0);
0613         sonic_rda_put(dev, entry, SONIC_RD_IN_USE, 1);
0614
0615         prev_entry = entry;
0616         entry = (entry + 1) & SONIC_RDS_MASK;
0617     }
0618
0619     lp->cur_rx = entry;
0620
0621     if (prev_entry != lp->eol_rx) {
0622         /* Advance the EOL flag to put descriptors back into service */
0623         sonic_rda_put(dev, prev_entry, SONIC_RD_LINK, SONIC_EOL |
0624                   sonic_rda_get(dev, prev_entry, SONIC_RD_LINK));
0625         sonic_rda_put(dev, lp->eol_rx, SONIC_RD_LINK, ~SONIC_EOL &
0626                   sonic_rda_get(dev, lp->eol_rx, SONIC_RD_LINK));
0627         lp->eol_rx = prev_entry;
0628     }
0629
0630     if (rbe)
0631         SONIC_WRITE(SONIC_ISR, SONIC_INT_RBE);
0632 }
0633
0634
0635 /*
0636  * Get the current statistics.
0637  * This may be called with the device open or closed.
0638  */
0639 static struct net_device_stats *sonic_get_stats(struct net_device *dev)
0640 {
0641     struct sonic_local *lp = netdev_priv(dev);
0642
0643     /* read the tally counter from the SONIC and reset them */
0644     lp->stats.rx_crc_errors += SONIC_READ(SONIC_CRCT);
0645     SONIC_WRITE(SONIC_CRCT, 0xffff);
0646     lp->stats.rx_frame_errors += SONIC_READ(SONIC_FAET);
0647     SONIC_WRITE(SONIC_FAET, 0xffff);
0648     lp->stats.rx_missed_errors += SONIC_READ(SONIC_MPT);
0649     SONIC_WRITE(SONIC_MPT, 0xffff);
0650
0651     return &lp->stats;
0652 }
0653
0654
0655 /*
0656  * Set or clear the multicast filter for this adaptor.
0657  */
0658 static void sonic_multicast_list(struct net_device *dev)
0659 {
0660     struct sonic_local *lp = netdev_priv(dev);
0661     unsigned int rcr;
0662     struct netdev_hw_addr *ha;
0663     unsigned char *addr;
0664     int i;
0665
0666     rcr = SONIC_READ(SONIC_RCR) & ~(SONIC_RCR_PRO | SONIC_RCR_AMC);
0667     rcr |= SONIC_RCR_BRD;   /* accept broadcast packets */
0668
0669     if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
0670         rcr |= SONIC_RCR_PRO;
0671     } else {
0672         if ((dev->flags & IFF_ALLMULTI) ||
0673             (netdev_mc_count(dev) > 15)) {
0674             rcr |= SONIC_RCR_AMC;
0675         } else {
0676             unsigned long flags;
0677
0678             netif_dbg(lp, ifup, dev, "%s: mc_count %d\n", __func__,
0679                   netdev_mc_count(dev));
0680             sonic_set_cam_enable(dev, 1);  /* always enable our own address */
0681             i = 1;
0682             netdev_for_each_mc_addr(ha, dev) {
0683                 addr = ha->addr;
0684                 sonic_cda_put(dev, i, SONIC_CD_CAP0, addr[1] << 8 | addr[0]);
0685                 sonic_cda_put(dev, i, SONIC_CD_CAP1, addr[3] << 8 | addr[2]);
0686                 sonic_cda_put(dev, i, SONIC_CD_CAP2, addr[5] << 8 | addr[4]);
0687                 sonic_set_cam_enable(dev, sonic_get_cam_enable(dev) | (1 << i));
0688                 i++;
0689             }
0690             SONIC_WRITE(SONIC_CDC, 16);
0691             SONIC_WRITE(SONIC_CDP, lp->cda_laddr & 0xffff);
0692
0693             /* LCAM and TXP commands can't be used simultaneously */
0694             spin_lock_irqsave(&lp->lock, flags);
0695             sonic_quiesce(dev, SONIC_CR_TXP, false);
0696             SONIC_WRITE(SONIC_CMD, SONIC_CR_LCAM);
0697             sonic_quiesce(dev, SONIC_CR_LCAM, false);
0698             spin_unlock_irqrestore(&lp->lock, flags);
0699         }
0700     }
0701
0702     netif_dbg(lp, ifup, dev, "%s: setting RCR=%x\n", __func__, rcr);
0703
0704     SONIC_WRITE(SONIC_RCR, rcr);
0705 }
0706
0707
0708 /*
0709  * Initialize the SONIC ethernet controller.
0710  */
0711 static int sonic_init(struct net_device *dev, bool may_sleep)
0712 {
0713     struct sonic_local *lp = netdev_priv(dev);
0714     int i;
0715
0716     /*
0717      * put the Sonic into software-reset mode and
0718      * disable all interrupts
0719      */
0720     SONIC_WRITE(SONIC_IMR, 0);
0721     SONIC_WRITE(SONIC_ISR, 0x7fff);
0722     SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
0723
0724     /* While in reset mode, clear CAM Enable register */
0725     SONIC_WRITE(SONIC_CE, 0);
0726
0727     /*
0728      * clear software reset flag, disable receiver, clear and
0729      * enable interrupts, then completely initialize the SONIC
0730      */
0731     SONIC_WRITE(SONIC_CMD, 0);
0732     SONIC_WRITE(SONIC_CMD, SONIC_CR_RXDIS | SONIC_CR_STP);
0733     sonic_quiesce(dev, SONIC_CR_ALL, may_sleep);
0734
0735     /*
0736      * initialize the receive resource area
0737      */
0738     netif_dbg(lp, ifup, dev, "%s: initialize receive resource area\n",
0739           __func__);
0740
0741     for (i = 0; i < SONIC_NUM_RRS; i++) {
0742         u16 bufadr_l = (unsigned long)lp->rx_laddr[i] & 0xffff;
0743         u16 bufadr_h = (unsigned long)lp->rx_laddr[i] >> 16;
0744         sonic_rra_put(dev, i, SONIC_RR_BUFADR_L, bufadr_l);
0745         sonic_rra_put(dev, i, SONIC_RR_BUFADR_H, bufadr_h);
0746         sonic_rra_put(dev, i, SONIC_RR_BUFSIZE_L, SONIC_RBSIZE >> 1);
0747         sonic_rra_put(dev, i, SONIC_RR_BUFSIZE_H, 0);
0748     }
0749
0750     /* initialize all RRA registers */
0751     SONIC_WRITE(SONIC_RSA, sonic_rr_addr(dev, 0));
0752     SONIC_WRITE(SONIC_REA, sonic_rr_addr(dev, SONIC_NUM_RRS));
0753     SONIC_WRITE(SONIC_RRP, sonic_rr_addr(dev, 0));
0754     SONIC_WRITE(SONIC_RWP, sonic_rr_addr(dev, SONIC_NUM_RRS - 1));
0755     SONIC_WRITE(SONIC_URRA, lp->rra_laddr >> 16);
0756     SONIC_WRITE(SONIC_EOBC, (SONIC_RBSIZE >> 1) - (lp->dma_bitmode ? 2 : 1));
0757
0758     /* load the resource pointers */
0759     netif_dbg(lp, ifup, dev, "%s: issuing RRRA command\n", __func__);
0760
0761     SONIC_WRITE(SONIC_CMD, SONIC_CR_RRRA);
0762     sonic_quiesce(dev, SONIC_CR_RRRA, may_sleep);
0763
0764     /*
0765      * Initialize the receive descriptors so that they
0766      * become a circular linked list, ie. let the last
0767      * descriptor point to the first again.
0768      */
0769     netif_dbg(lp, ifup, dev, "%s: initialize receive descriptors\n",
0770           __func__);
0771
0772     for (i=0; i<SONIC_NUM_RDS; i++) {
0773         sonic_rda_put(dev, i, SONIC_RD_STATUS, 0);
0774         sonic_rda_put(dev, i, SONIC_RD_PKTLEN, 0);
0775         sonic_rda_put(dev, i, SONIC_RD_PKTPTR_L, 0);
0776         sonic_rda_put(dev, i, SONIC_RD_PKTPTR_H, 0);
0777         sonic_rda_put(dev, i, SONIC_RD_SEQNO, 0);
0778         sonic_rda_put(dev, i, SONIC_RD_IN_USE, 1);
0779         sonic_rda_put(dev, i, SONIC_RD_LINK,
0780             lp->rda_laddr +
0781             ((i+1) * SIZEOF_SONIC_RD * SONIC_BUS_SCALE(lp->dma_bitmode)));
0782     }
0783     /* fix last descriptor */
0784     sonic_rda_put(dev, SONIC_NUM_RDS - 1, SONIC_RD_LINK,
0785         (lp->rda_laddr & 0xffff) | SONIC_EOL);
0786     lp->eol_rx = SONIC_NUM_RDS - 1;
0787     lp->cur_rx = 0;
0788     SONIC_WRITE(SONIC_URDA, lp->rda_laddr >> 16);
0789     SONIC_WRITE(SONIC_CRDA, lp->rda_laddr & 0xffff);
0790
0791     /*
0792      * initialize transmit descriptors
0793      */
0794     netif_dbg(lp, ifup, dev, "%s: initialize transmit descriptors\n",
0795           __func__);
0796
0797     for (i = 0; i < SONIC_NUM_TDS; i++) {
0798         sonic_tda_put(dev, i, SONIC_TD_STATUS, 0);
0799         sonic_tda_put(dev, i, SONIC_TD_CONFIG, 0);
0800         sonic_tda_put(dev, i, SONIC_TD_PKTSIZE, 0);
0801         sonic_tda_put(dev, i, SONIC_TD_FRAG_COUNT, 0);
0802         sonic_tda_put(dev, i, SONIC_TD_LINK,
0803             (lp->tda_laddr & 0xffff) +
0804             (i + 1) * SIZEOF_SONIC_TD * SONIC_BUS_SCALE(lp->dma_bitmode));
0805         lp->tx_skb[i] = NULL;
0806     }
0807     /* fix last descriptor */
0808     sonic_tda_put(dev, SONIC_NUM_TDS - 1, SONIC_TD_LINK,
0809         (lp->tda_laddr & 0xffff));
0810
0811     SONIC_WRITE(SONIC_UTDA, lp->tda_laddr >> 16);
0812     SONIC_WRITE(SONIC_CTDA, lp->tda_laddr & 0xffff);
0813     lp->cur_tx = 0;
0814     lp->eol_tx = SONIC_NUM_TDS - 1;
0815
0816     /*
0817      * put our own address to CAM desc[0]
0818      */
0819     sonic_cda_put(dev, 0, SONIC_CD_CAP0, dev->dev_addr[1] << 8 | dev->dev_addr[0]);
0820     sonic_cda_put(dev, 0, SONIC_CD_CAP1, dev->dev_addr[3] << 8 | dev->dev_addr[2]);
0821     sonic_cda_put(dev, 0, SONIC_CD_CAP2, dev->dev_addr[5] << 8 | dev->dev_addr[4]);
0822     sonic_set_cam_enable(dev, 1);
0823
0824     for (i = 0; i < 16; i++)
0825         sonic_cda_put(dev, i, SONIC_CD_ENTRY_POINTER, i);
0826
0827     /*
0828      * initialize CAM registers
0829      */
0830     SONIC_WRITE(SONIC_CDP, lp->cda_laddr & 0xffff);
0831     SONIC_WRITE(SONIC_CDC, 16);
0832
0833     /*
0834      * load the CAM
0835      */
0836     SONIC_WRITE(SONIC_CMD, SONIC_CR_LCAM);
0837     sonic_quiesce(dev, SONIC_CR_LCAM, may_sleep);
0838
0839     /*
0840      * enable receiver, disable loopback
0841      * and enable all interrupts
0842      */
0843     SONIC_WRITE(SONIC_RCR, SONIC_RCR_DEFAULT);
0844     SONIC_WRITE(SONIC_TCR, SONIC_TCR_DEFAULT);
0845     SONIC_WRITE(SONIC_ISR, 0x7fff);
0846     SONIC_WRITE(SONIC_IMR, SONIC_IMR_DEFAULT);
0847     SONIC_WRITE(SONIC_CMD, SONIC_CR_RXEN);
0848
0849     netif_dbg(lp, ifup, dev, "%s: new status=%x\n", __func__,
0850           SONIC_READ(SONIC_CMD));
0851
0852     return 0;
0853 }
0854
0855 MODULE_LICENSE("GPL");