sys/dev/netif/lnc/if_lnc.c

   1 /*-
   2  * Copyright (c) 1994-2000
   3  *      Paul Richards.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    verbatim and that no modifications are made prior to this
  11  *    point in the file.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name Paul Richards may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY PAUL RICHARDS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL PAUL RICHARDS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * $FreeBSD: src/sys/dev/lnc/if_lnc.c,v 1.89 2001/07/04 13:00:19 nyan Exp $
  31  * $DragonFly: src/sys/dev/netif/lnc/Attic/if_lnc.c,v 1.9 2004/03/23 22:19:01 hsu Exp $
  32  */
  33
  34 /*
  35 #define DIAGNOSTIC
  36 #define DEBUG
  37  *
  38  * TODO ----
  39  *
  40  * Check all the XXX comments -- some of them are just things I've left
  41  * unfinished rather than "difficult" problems that were hacked around.
  42  *
  43  * Check log settings.
  44  *
  45  * Check how all the arpcom flags get set and used.
  46  *
  47  * Re-inline and re-static all routines after debugging.
  48  *
  49  * Remember to assign iobase in SHMEM probe routines.
  50  *
  51  * Replace all occurences of LANCE-controller-card etc in prints by the name
  52  * strings of the appropriate type -- nifty window dressing
  53  *
  54  * Add DEPCA support -- mostly done.
  55  *
  56  */
  57
  58 #include "opt_inet.h"
  59
  60 /* Some defines that should really be in generic locations */
  61 #define FCS_LEN 4
  62 #define MULTICAST_FILTER_LEN 8
  63
  64 #include <sys/param.h>
  65 #include <sys/systm.h>
  66 #include <sys/bus.h>
  67 #include <sys/kernel.h>
  68 #include <sys/malloc.h>
  69 #include <sys/mbuf.h>
  70 #include <sys/module.h>
  71 #include <sys/socket.h>
  72 #include <sys/sockio.h>
  73 #include <sys/syslog.h>
  74
  75 #include <machine/bus.h>
  76 #include <machine/resource.h>
  77 #include <sys/rman.h>
  78
  79 #include <net/ethernet.h>
  80 #include <net/if.h>
  81 #include <net/if_dl.h>
  82 #include <net/if_types.h>
  83
  84 #include <netinet/in.h>
  85 #include <netinet/if_ether.h>
  86
  87 #include <net/bpf.h>
  88
  89 #include <machine/md_var.h>
  90
  91 #include <dev/netif/lnc/if_lncvar.h>
  92 #include <dev/netif/lnc/if_lncreg.h>
  93
  94 DECLARE_DUMMY_MODULE(if_lnc);
  95
  96 devclass_t lnc_devclass;
  97
  98 static char const * const nic_ident[] = {
  99         "Unknown",
 100         "BICC",
 101         "NE2100",
 102         "DEPCA",
 103         "CNET98S",      /* PC-98 */
 104 };
 105
 106 static char const * const ic_ident[] = {
 107         "Unknown",
 108         "LANCE",
 109         "C-LANCE",
 110         "PCnet-ISA",
 111         "PCnet-ISA+",
 112         "PCnet-ISA II",
 113         "PCnet-32 VL-Bus",
 114         "PCnet-PCI",
 115         "PCnet-PCI II",
 116         "PCnet-FAST",
 117         "PCnet-FAST+",
 118         "PCnet-Home",
 119 };
 120
 121 static void lnc_setladrf(struct lnc_softc *sc);
 122 static void lnc_reset(struct lnc_softc *sc);
 123 static void lnc_free_mbufs(struct lnc_softc *sc);
 124 static __inline int alloc_mbuf_cluster(struct lnc_softc *sc,
 125                                             struct host_ring_entry *desc);
 126 static __inline struct mbuf *chain_mbufs(struct lnc_softc *sc,
 127                                               int start_of_packet,
 128                                               int pkt_len);
 129 static __inline struct mbuf *mbuf_packet(struct lnc_softc *sc,
 130                                               int start_of_packet,
 131                                               int pkt_len);
 132 static __inline void lnc_rint(struct lnc_softc *sc);
 133 static __inline void lnc_tint(struct lnc_softc *sc);
 134
 135 static void lnc_init(void *);
 136 static __inline int mbuf_to_buffer(struct mbuf *m, char *buffer);
 137 static __inline struct mbuf *chain_to_cluster(struct mbuf *m);
 138 static void lnc_start(struct ifnet *ifp);
 139 static int lnc_ioctl(struct ifnet *ifp, u_long command, caddr_t data,
 140                      struct ucred *);
 141 static void lnc_watchdog(struct ifnet *ifp);
 142 #ifdef DEBUG
 143 void lnc_dump_state(struct lnc_softc *sc);
 144 void mbuf_dump_chain(struct mbuf *m);
 145 #endif
 146
 147 u_short
 148 read_csr(struct lnc_softc *sc, u_short port)
 149 {
 150         lnc_outw(sc->rap, port);
 151         return (lnc_inw(sc->rdp));
 152 }
 153
 154 void
 155 write_csr(struct lnc_softc *sc, u_short port, u_short val)
 156 {
 157         lnc_outw(sc->rap, port);
 158         lnc_outw(sc->rdp, val);
 159 }
 160
 161 static __inline void
 162 write_bcr(struct lnc_softc *sc, u_short port, u_short val)
 163 {
 164         lnc_outw(sc->rap, port);
 165         lnc_outw(sc->bdp, val);
 166 }
 167
 168 static __inline u_short
 169 read_bcr(struct lnc_softc *sc, u_short port)
 170 {
 171         lnc_outw(sc->rap, port);
 172         return (lnc_inw(sc->bdp));
 173 }
 174
 175 int
 176 lance_probe(struct lnc_softc *sc)
 177 {
 178         write_csr(sc, CSR0, STOP);
 179
 180         if ((lnc_inw(sc->rdp) & STOP) && ! (read_csr(sc, CSR3))) {
 181                 /*
 182                  * Check to see if it's a C-LANCE. For the LANCE the INEA bit
 183                  * cannot be set while the STOP bit is. This restriction is
 184                  * removed for the C-LANCE.
 185                  */
 186                 write_csr(sc, CSR0, INEA);
 187                 if (read_csr(sc, CSR0) & INEA)
 188                         return (C_LANCE);
 189                 else
 190                         return (LANCE);
 191         } else
 192                 return (UNKNOWN);
 193 }
 194
 195 static __inline u_long
 196 ether_crc(const u_char *ether_addr)
 197 {
 198 #define POLYNOMIAL           0xEDB88320UL
 199     u_char i, j, addr;
 200     u_int crc = 0xFFFFFFFFUL;
 201
 202     for (i = 0; i < ETHER_ADDR_LEN; i++) {
 203         addr = *ether_addr++;
 204         for (j = 0; j < MULTICAST_FILTER_LEN; j++) {
 205             crc = (crc >> 1) ^ (((crc ^ addr) & 1) ? POLYNOMIAL : 0);
 206             addr >>= 1;
 207         }
 208     }
 209     return crc;
 210 #undef POLYNOMIAL
 211 }
 212
 213 void
 214 lnc_release_resources(device_t dev)
 215 {
 216         lnc_softc_t *sc = device_get_softc(dev);
 217
 218         if (sc->irqres) {
 219                 bus_teardown_intr(dev, sc->irqres, sc->intrhand);
 220                 bus_release_resource(dev, SYS_RES_IRQ, sc->irqrid, sc->irqres);
 221         }
 222
 223         if (sc->portres)
 224                 bus_release_resource(dev, SYS_RES_IOPORT,
 225                                      sc->portrid, sc->portres);
 226         if (sc->drqres)
 227                 bus_release_resource(dev, SYS_RES_DRQ, sc->drqrid, sc->drqres);
 228
 229         if (sc->dmat) {
 230                 if (sc->dmamap) {
 231                         bus_dmamap_unload(sc->dmat, sc->dmamap);
 232                         bus_dmamem_free(sc->dmat, sc->recv_ring, sc->dmamap);
 233                 }
 234                 bus_dma_tag_destroy(sc->dmat);
 235         }
 236 }
 237
 238 /*
 239  * Set up the logical address filter for multicast packets
 240  */
 241 static __inline void
 242 lnc_setladrf(struct lnc_softc *sc)
 243 {
 244         struct ifnet *ifp = &sc->arpcom.ac_if;
 245         struct ifmultiaddr *ifma;
 246         u_long index;
 247         int i;
 248
 249         if (sc->flags & IFF_ALLMULTI) {
 250             for (i=0; i < MULTICAST_FILTER_LEN; i++)
 251                 sc->init_block->ladrf[i] = 0xFF;
 252             return;
 253         }
 254
 255         /*
 256          * For each multicast address, calculate a crc for that address and
 257          * then use the high order 6 bits of the crc as a hash code where
 258          * bits 3-5 select the byte of the address filter and bits 0-2 select
 259          * the bit within that byte.
 260          */
 261
 262         bzero(sc->init_block->ladrf, MULTICAST_FILTER_LEN);
 263         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 264                 if (ifma->ifma_addr->sa_family != AF_LINK)
 265                         continue;
 266
 267                 index = ether_crc(LLADDR((struct sockaddr_dl *)ifma->ifma_addr))
 268                                 >> 26;
 269                 sc->init_block->ladrf[index >> 3] |= 1 << (index & 7);
 270         }
 271 }
 272
 273 void
 274 lnc_stop(struct lnc_softc *sc)
 275 {
 276         write_csr(sc, CSR0, STOP);
 277 }
 278
 279 static void
 280 lnc_reset(struct lnc_softc *sc)
 281 {
 282         lnc_init(sc);
 283 }
 284
 285 static void
 286 lnc_free_mbufs(struct lnc_softc *sc)
 287 {
 288         int i;
 289
 290         /*
 291          * We rely on other routines to keep the buff.mbuf field valid. If
 292          * it's not NULL then we assume it points to an allocated mbuf.
 293          */
 294
 295         for (i = 0; i < NDESC(sc->nrdre); i++)
 296                 if ((sc->recv_ring + i)->buff.mbuf)
 297                         m_free((sc->recv_ring + i)->buff.mbuf);
 298
 299         for (i = 0; i < NDESC(sc->ntdre); i++)
 300                 if ((sc->trans_ring + i)->buff.mbuf)
 301                         m_free((sc->trans_ring + i)->buff.mbuf);
 302
 303         if (sc->mbuf_count)
 304                 m_freem(sc->mbufs);
 305 }
 306
 307 static __inline int
 308 alloc_mbuf_cluster(struct lnc_softc *sc, struct host_ring_entry *desc)
 309 {
 310         register struct mds *md = desc->md;
 311         struct mbuf *m=0;
 312         int addr;
 313
 314         /* Try and get cluster off local cache */
 315         if (sc->mbuf_count) {
 316                 sc->mbuf_count--;
 317                 m = sc->mbufs;
 318                 sc->mbufs = m->m_next;
 319                 /* XXX m->m_data = m->m_ext.ext_buf;*/
 320         } else {
 321                 MGET(m, M_DONTWAIT, MT_DATA);
 322         if (!m)
 323                         return(1);
 324       MCLGET(m, M_DONTWAIT);
 325         if (!m->m_ext.ext_buf) {
 326                         m_free(m);
 327                         return(1);
 328                 }
 329         }
 330
 331         desc->buff.mbuf = m;
 332         addr = kvtop(m->m_data);
 333         md->md0 = addr;
 334         md->md1= ((addr >> 16) & 0xff) | OWN;
 335         md->md2 = -(short)(MCLBYTES - sizeof(struct pkthdr));
 336         md->md3 = 0;
 337         return(0);
 338 }
 339
 340 static __inline struct mbuf *
 341 chain_mbufs(struct lnc_softc *sc, int start_of_packet, int pkt_len)
 342 {
 343         struct mbuf *head, *m;
 344         struct host_ring_entry *desc;
 345
 346         /*
 347          * Turn head into a pkthdr mbuf --
 348          * assumes a pkthdr type mbuf was
 349          * allocated to the descriptor
 350          * originally.
 351          */
 352
 353         desc = sc->recv_ring + start_of_packet;
 354
 355         head = desc->buff.mbuf;
 356         head->m_flags |= M_PKTHDR;
 357         bzero(&head->m_pkthdr, sizeof(head->m_pkthdr));
 358
 359         m = head;
 360         do {
 361                 m = desc->buff.mbuf;
 362                 m->m_len = min((MCLBYTES - sizeof(struct pkthdr)), pkt_len);
 363                 pkt_len -= m->m_len;
 364                 if (alloc_mbuf_cluster(sc, desc))
 365                         return((struct mbuf *)NULL);
 366                 INC_MD_PTR(start_of_packet, sc->nrdre)
 367                 desc = sc->recv_ring + start_of_packet;
 368                 m->m_next = desc->buff.mbuf;
 369         } while (start_of_packet != sc->recv_next);
 370
 371         m->m_next = 0;
 372         return(head);
 373 }
 374
 375 static __inline struct mbuf *
 376 mbuf_packet(struct lnc_softc *sc, int start_of_packet, int pkt_len)
 377 {
 378
 379         struct host_ring_entry *start;
 380         struct mbuf *head,*m,*m_prev;
 381         char *data,*mbuf_data;
 382         short blen;
 383         int amount;
 384
 385         /* Get a pkthdr mbuf for the start of packet */
 386         MGETHDR(head, M_DONTWAIT, MT_DATA);
 387         if (!head) {
 388                 LNCSTATS(drop_packet)
 389                 return(0);
 390         }
 391
 392         m = head;
 393         m->m_len = 0;
 394         start = sc->recv_ring + start_of_packet;
 395         /*blen = -(start->md->md2);*/
 396         blen = RECVBUFSIZE; /* XXX More PCnet-32 crap */
 397         data = start->buff.data;
 398         mbuf_data = m->m_data;
 399
 400         while (start_of_packet != sc->recv_next) {
 401                 /*
 402                  * If the data left fits in a single buffer then set
 403                  * blen to the size of the data left.
 404                  */
 405                 if (pkt_len < blen)
 406                         blen = pkt_len;
 407
 408                 /*
 409                  * amount is least of data in current ring buffer and
 410                  * amount of space left in current mbuf.
 411                  */
 412                 amount = min(blen, M_TRAILINGSPACE(m));
 413                 if (amount == 0) {
 414                         /* mbuf must be empty */
 415                         m_prev = m;
 416                         MGET(m, M_DONTWAIT, MT_DATA);
 417                         if (!m) {
 418                                 m_freem(head);
 419                                 return(0);
 420                         }
 421                         if (pkt_len >= MINCLSIZE)
 422                                 MCLGET(m, M_DONTWAIT);
 423                         m->m_len = 0;
 424                         m_prev->m_next = m;
 425                         amount = min(blen, M_TRAILINGSPACE(m));
 426                         mbuf_data = m->m_data;
 427                 }
 428                 bcopy(data, mbuf_data, amount);
 429                 blen -= amount;
 430                 pkt_len -= amount;
 431                 m->m_len += amount;
 432                 data += amount;
 433                 mbuf_data += amount;
 434
 435                 if (blen == 0) {
 436                         start->md->md1 &= HADR;
 437                         start->md->md1 |= OWN;
 438                         start->md->md2 = -RECVBUFSIZE; /* XXX - shouldn't be necessary */
 439                         INC_MD_PTR(start_of_packet, sc->nrdre)
 440                         start = sc->recv_ring + start_of_packet;
 441                         data = start->buff.data;
 442                         /*blen = -(start->md->md2);*/
 443                         blen = RECVBUFSIZE; /* XXX More PCnet-32 crap */
 444                 }
 445         }
 446         return(head);
 447 }
 448
 449
 450 static __inline void
 451 lnc_rint(struct lnc_softc *sc)
 452 {
 453         struct host_ring_entry *next, *start;
 454         int start_of_packet;
 455         struct mbuf *head;
 456         struct ether_header *eh;
 457         int lookahead;
 458         int flags;
 459         int pkt_len;
 460
 461         /*
 462          * The LANCE will issue a RINT interrupt when the ownership of the
 463          * last buffer of a receive packet has been relinquished by the LANCE.
 464          * Therefore, it can be assumed that a complete packet can be found
 465          * before hitting buffers that are still owned by the LANCE, if not
 466          * then there is a bug in the driver that is causing the descriptors
 467          * to get out of sync.
 468          */
 469
 470 #ifdef DIAGNOSTIC
 471         if ((sc->recv_ring + sc->recv_next)->md->md1 & OWN) {
 472                 int unit = sc->arpcom.ac_if.if_dunit;
 473                 log(LOG_ERR, "lnc%d: Receive interrupt with buffer still owned by controller -- Resetting\n", unit);
 474                 lnc_reset(sc);
 475                 return;
 476         }
 477         if (!((sc->recv_ring + sc->recv_next)->md->md1 & STP)) {
 478                 int unit = sc->arpcom.ac_if.if_dunit;
 479                 log(LOG_ERR, "lnc%d: Receive interrupt but not start of packet -- Resetting\n", unit);
 480                 lnc_reset(sc);
 481                 return;
 482         }
 483 #endif
 484
 485         lookahead = 0;
 486         next = sc->recv_ring + sc->recv_next;
 487         while ((flags = next->md->md1) & STP) {
 488
 489                 /* Make a note of the start of the packet */
 490                 start_of_packet = sc->recv_next;
 491
 492                 /*
 493                  * Find the end of the packet. Even if not data chaining,
 494                  * jabber packets can overrun into a second descriptor.
 495                  * If there is no error, then the ENP flag is set in the last
 496                  * descriptor of the packet. If there is an error then the ERR
 497                  * flag will be set in the descriptor where the error occured.
 498                  * Therefore, to find the last buffer of a packet we search for
 499                  * either ERR or ENP.
 500                  */
 501
 502                 if (!(flags & (ENP | MDERR))) {
 503                         do {
 504                                 INC_MD_PTR(sc->recv_next, sc->nrdre)
 505                                 next = sc->recv_ring + sc->recv_next;
 506                                 flags = next->md->md1;
 507                         } while (!(flags & (STP | OWN | ENP | MDERR)));
 508
 509                         if (flags & STP) {
 510                                 int unit = sc->arpcom.ac_if.if_dunit;
 511                                 log(LOG_ERR, "lnc%d: Start of packet found before end of previous in receive ring -- Resetting\n", unit);
 512                                 lnc_reset(sc);
 513                                 return;
 514                         }
 515                         if (flags & OWN) {
 516                                 if (lookahead) {
 517                                         /*
 518                                          * Looked ahead into a packet still
 519                                          * being received
 520                                          */
 521                                         sc->recv_next = start_of_packet;
 522                                         break;
 523                                 } else {
 524                                         int unit = sc->arpcom.ac_if.if_dunit;
 525                                         log(LOG_ERR, "lnc%d: End of received packet not found-- Resetting\n", unit);
 526                                         lnc_reset(sc);
 527                                         return;
 528                                 }
 529                         }
 530                 }
 531
 532                 pkt_len = (next->md->md3 & MCNT) - FCS_LEN;
 533
 534                 /* Move pointer onto start of next packet */
 535                 INC_MD_PTR(sc->recv_next, sc->nrdre)
 536                 next = sc->recv_ring + sc->recv_next;
 537
 538                 if (flags & MDERR) {
 539                         int unit = sc->arpcom.ac_if.if_dunit;
 540                         if (flags & RBUFF) {
 541                                 LNCSTATS(rbuff)
 542                                 log(LOG_ERR, "lnc%d: Receive buffer error\n", unit);
 543                         }
 544                         if (flags & OFLO) {
 545                                 /* OFLO only valid if ENP is not set */
 546                                 if (!(flags & ENP)) {
 547                                         LNCSTATS(oflo)
 548                                         log(LOG_ERR, "lnc%d: Receive overflow error \n", unit);
 549                                 }
 550                         } else if (flags & ENP) {
 551                             if ((sc->arpcom.ac_if.if_flags & IFF_PROMISC)==0) {
 552                                 /*
 553                                  * FRAM and CRC are valid only if ENP
 554                                  * is set and OFLO is not.
 555                                  */
 556                                 if (flags & FRAM) {
 557                                         LNCSTATS(fram)
 558                                         log(LOG_ERR, "lnc%d: Framing error\n", unit);
 559                                         /*
 560                                          * FRAM is only set if there's a CRC
 561                                          * error so avoid multiple messages
 562                                          */
 563                                 } else if (flags & CRC) {
 564                                         LNCSTATS(crc)
 565                                         log(LOG_ERR, "lnc%d: Receive CRC error\n", unit);
 566                                 }
 567                             }
 568                         }
 569
 570                         /* Drop packet */
 571                         LNCSTATS(rerr)
 572                         sc->arpcom.ac_if.if_ierrors++;
 573                         while (start_of_packet != sc->recv_next) {
 574                                 start = sc->recv_ring + start_of_packet;
 575                                 start->md->md2 = -RECVBUFSIZE; /* XXX - shouldn't be necessary */
 576                                 start->md->md1 &= HADR;
 577                                 start->md->md1 |= OWN;
 578                                 INC_MD_PTR(start_of_packet, sc->nrdre)
 579                         }
 580                 } else { /* Valid packet */
 581
 582                         sc->arpcom.ac_if.if_ipackets++;
 583
 584
 585                         if (sc->nic.mem_mode == DMA_MBUF)
 586                                 head = chain_mbufs(sc, start_of_packet, pkt_len);
 587                         else
 588                                 head = mbuf_packet(sc, start_of_packet, pkt_len);
 589
 590                         if (head) {
 591                                 /*
 592                                  * First mbuf in packet holds the
 593                                  * ethernet and packet headers
 594                                  */
 595                                 head->m_pkthdr.rcvif = &sc->arpcom.ac_if;
 596                                 head->m_pkthdr.len = pkt_len ;
 597                                 eh = (struct ether_header *) head->m_data;
 598
 599                                 /*
 600                                  * vmware ethernet hardware emulation loops
 601                                  * packets back to itself, violates IFF_SIMPLEX.
 602                                  * drop it if it is from myself.
 603                                 */
 604                                 if (bcmp(eh->ether_shost,
 605                                       sc->arpcom.ac_enaddr, ETHER_ADDR_LEN) == 0) {
 606                                     m_freem(head);
 607                                 } else {
 608                                     /* Skip over the ether header */
 609                                     head->m_data += sizeof *eh;
 610                                     head->m_len -= sizeof *eh;
 611                                     head->m_pkthdr.len -= sizeof *eh;
 612
 613                                     ether_input(&sc->arpcom.ac_if, eh, head);
 614                                 }
 615                         } else {
 616                                 int unit = sc->arpcom.ac_if.if_dunit;
 617                                 log(LOG_ERR,"lnc%d: Packet dropped, no mbufs\n",unit);
 618                                 LNCSTATS(drop_packet)
 619                         }
 620                 }
 621
 622                 lookahead++;
 623         }
 624
 625         /*
 626          * At this point all completely received packets have been processed
 627          * so clear RINT since any packets that have arrived while we were in
 628          * here have been dealt with.
 629          */
 630
 631         lnc_outw(sc->rdp, RINT | INEA);
 632 }
 633
 634 static __inline void
 635 lnc_tint(struct lnc_softc *sc)
 636 {
 637         struct host_ring_entry *next, *start;
 638         int start_of_packet;
 639         int lookahead;
 640
 641         /*
 642          * If the driver is reset in this routine then we return immediately to
 643          * the interrupt driver routine. Any interrupts that have occured
 644          * since the reset will be dealt with there. sc->trans_next
 645          * should point to the start of the first packet that was awaiting
 646          * transmission after the last transmit interrupt was dealt with. The
 647          * LANCE should have relinquished ownership of that descriptor before
 648          * the interrupt. Therefore, sc->trans_next should point to a
 649          * descriptor with STP set and OWN cleared. If not then the driver's
 650          * pointers are out of sync with the LANCE, which signifies a bug in
 651          * the driver. Therefore, the following two checks are really
 652          * diagnostic, since if the driver is working correctly they should
 653          * never happen.
 654          */
 655
 656 #ifdef DIAGNOSTIC
 657         if ((sc->trans_ring + sc->trans_next)->md->md1 & OWN) {
 658                 int unit = sc->arpcom.ac_if.if_dunit;
 659                 log(LOG_ERR, "lnc%d: Transmit interrupt with buffer still owned by controller -- Resetting\n", unit);
 660                 lnc_reset(sc);
 661                 return;
 662         }
 663 #endif
 664
 665
 666         /*
 667          * The LANCE will write the status information for the packet it just
 668          * tried to transmit in one of two places. If the packet was
 669          * transmitted successfully then the status will be written into the
 670          * last descriptor of the packet. If the transmit failed then the
 671          * status will be written into the descriptor that was being accessed
 672          * when the error occured and all subsequent descriptors in that
 673          * packet will have been relinquished by the LANCE.
 674          *
 675          * At this point we know that sc->trans_next points to the start
 676          * of a packet that the LANCE has just finished trying to transmit.
 677          * We now search for a buffer with either ENP or ERR set.
 678          */
 679
 680         lookahead = 0;
 681
 682         do {
 683                 start_of_packet = sc->trans_next;
 684                 next = sc->trans_ring + sc->trans_next;
 685
 686 #ifdef DIAGNOSTIC
 687         if (!(next->md->md1 & STP)) {
 688                 int unit = sc->arpcom.ac_if.if_dunit;
 689                 log(LOG_ERR, "lnc%d: Transmit interrupt but not start of packet -- Resetting\n", unit);
 690                 lnc_reset(sc);
 691                 return;
 692         }
 693 #endif
 694
 695                 /*
 696                  * Find end of packet.
 697                  */
 698
 699                 if (!(next->md->md1 & (ENP | MDERR))) {
 700                         do {
 701                                 INC_MD_PTR(sc->trans_next, sc->ntdre)
 702                                 next = sc->trans_ring + sc->trans_next;
 703                         } while (!(next->md->md1 & (STP | OWN | ENP | MDERR)));
 704
 705                         if (next->md->md1 & STP) {
 706                                 int unit = sc->arpcom.ac_if.if_dunit;
 707                                 log(LOG_ERR, "lnc%d: Start of packet found before end of previous in transmit ring -- Resetting\n", unit);
 708                                 lnc_reset(sc);
 709                                 return;
 710                         }
 711                         if (next->md->md1 & OWN) {
 712                                 if (lookahead) {
 713                                         /*
 714                                          * Looked ahead into a packet still
 715                                          * being transmitted
 716                                          */
 717                                         sc->trans_next = start_of_packet;
 718                                         break;
 719                                 } else {
 720                                         int unit = sc->arpcom.ac_if.if_dunit;
 721                                         log(LOG_ERR, "lnc%d: End of transmitted packet not found -- Resetting\n", unit);
 722                                         lnc_reset(sc);
 723                                         return;
 724                                 }
 725                         }
 726                 }
 727                 /*
 728                  * Check for ERR first since other flags are irrelevant if an
 729                  * error occurred.
 730                  */
 731                 if (next->md->md1 & MDERR) {
 732
 733                         int unit = sc->arpcom.ac_if.if_dunit;
 734
 735                         LNCSTATS(terr)
 736                                 sc->arpcom.ac_if.if_oerrors++;
 737
 738                         if (next->md->md3 & LCOL) {
 739                                 LNCSTATS(lcol)
 740                                 log(LOG_ERR, "lnc%d: Transmit late collision  -- Net error?\n", unit);
 741                                 sc->arpcom.ac_if.if_collisions++;
 742                                 /*
 743                                  * Clear TBUFF since it's not valid when LCOL
 744                                  * set
 745                                  */
 746                                 next->md->md3 &= ~TBUFF;
 747                         }
 748                         if (next->md->md3 & LCAR) {
 749                                 LNCSTATS(lcar)
 750                                 log(LOG_ERR, "lnc%d: Loss of carrier during transmit -- Net error?\n", unit);
 751                         }
 752                         if (next->md->md3 & RTRY) {
 753                                 LNCSTATS(rtry)
 754                                 log(LOG_ERR, "lnc%d: Transmit of packet failed after 16 attempts -- TDR = %d\n", unit, ((sc->trans_ring + sc->trans_next)->md->md3 & TDR));
 755                                 sc->arpcom.ac_if.if_collisions += 16;
 756                                 /*
 757                                  * Clear TBUFF since it's not valid when RTRY
 758                                  * set
 759                                  */
 760                                 next->md->md3 &= ~TBUFF;
 761                         }
 762                         /*
 763                          * TBUFF is only valid if neither LCOL nor RTRY are set.
 764                          * We need to check UFLO after LCOL and RTRY so that we
 765                          * know whether or not TBUFF is valid. If either are
 766                          * set then TBUFF will have been cleared above. A
 767                          * UFLO error will turn off the transmitter so we
 768                          * have to reset.
 769                          *
 770                          */
 771
 772                         if (next->md->md3 & UFLO) {
 773                                 LNCSTATS(uflo)
 774                                 /*
 775                                  * If an UFLO has occured it's possibly due
 776                                  * to a TBUFF error
 777                                  */
 778                                 if (next->md->md3 & TBUFF) {
 779                                         LNCSTATS(tbuff)
 780                                         log(LOG_ERR, "lnc%d: Transmit buffer error -- Resetting\n", unit);
 781                                 } else
 782                                         log(LOG_ERR, "lnc%d: Transmit underflow error -- Resetting\n", unit);
 783                                 lnc_reset(sc);
 784                                 return;
 785                         }
 786                         do {
 787                                 INC_MD_PTR(sc->trans_next, sc->ntdre)
 788                                 next = sc->trans_ring + sc->trans_next;
 789                         } while (!(next->md->md1 & STP) && (sc->trans_next != sc->next_to_send));
 790
 791                 } else {
 792                         /*
 793                          * Since we check for ERR first then if we get here
 794                          * the packet was transmitted correctly. There may
 795                          * still have been non-fatal errors though.
 796                          * Don't bother checking for DEF, waste of time.
 797                          */
 798
 799                         sc->arpcom.ac_if.if_opackets++;
 800
 801                         if (next->md->md1 & MORE) {
 802                                 LNCSTATS(more)
 803                                 sc->arpcom.ac_if.if_collisions += 2;
 804                         }
 805
 806                         /*
 807                          * ONE is invalid if LCOL is set. If LCOL was set then
 808                          * ERR would have also been set and we would have
 809                          * returned from lnc_tint above. Therefore we can
 810                          * assume if we arrive here that ONE is valid.
 811                          *
 812                          */
 813
 814                         if (next->md->md1 & ONE) {
 815                                 LNCSTATS(one)
 816                                 sc->arpcom.ac_if.if_collisions++;
 817                         }
 818                         INC_MD_PTR(sc->trans_next, sc->ntdre)
 819                         next = sc->trans_ring + sc->trans_next;
 820                 }
 821
 822                 /*
 823                  * Clear descriptors and free any mbufs.
 824                  */
 825
 826                 do {
 827                         start = sc->trans_ring + start_of_packet;
 828                         start->md->md1 &= HADR;
 829                         if (sc->nic.mem_mode == DMA_MBUF) {
 830                                 /* Cache clusters on a local queue */
 831                                 if ((start->buff.mbuf->m_flags & M_EXT) && (sc->mbuf_count < MBUF_CACHE_LIMIT)) {
 832                                         if (sc->mbuf_count) {
 833                                                 start->buff.mbuf->m_next = sc->mbufs;
 834                                                 sc->mbufs = start->buff.mbuf;
 835                                         } else
 836                                                 sc->mbufs = start->buff.mbuf;
 837                                         sc->mbuf_count++;
 838                                         start->buff.mbuf = 0;
 839                                 } else {
 840                                         m_free(start->buff.mbuf);
 841                                         start->buff.mbuf = NULL;
 842                                 }
 843                         }
 844                         sc->pending_transmits--;
 845                         INC_MD_PTR(start_of_packet, sc->ntdre)
 846                 }while (start_of_packet != sc->trans_next);
 847
 848                 /*
 849                  * There's now at least one free descriptor
 850                  * in the ring so indicate that we can accept
 851                  * more packets again.
 852                  */
 853
 854                 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
 855
 856                 lookahead++;
 857
 858         } while (sc->pending_transmits && !(next->md->md1 & OWN));
 859
 860         /*
 861          * Clear TINT since we've dealt with all
 862          * the completed transmissions.
 863          */
 864
 865         lnc_outw(sc->rdp, TINT | INEA);
 866 }
 867
 868 int
 869 lnc_attach_common(device_t dev)
 870 {
 871         int unit = device_get_unit(dev);
 872         lnc_softc_t *sc = device_get_softc(dev);
 873         int i;
 874         int skip;
 875
 876         switch (sc->nic.ident) {
 877         case BICC:
 878         case CNET98S:
 879                 skip = 2;
 880                 break;
 881         default:
 882                 skip = 1;
 883                 break;
 884         }
 885
 886         /* Set default mode */
 887         sc->nic.mode = NORMAL;
 888
 889         /* Fill in arpcom structure entries */
 890
 891         sc->arpcom.ac_if.if_softc = sc;
 892         if_initname(&(sc->arpcom.ac_if), "lnc", unit);
 893         sc->arpcom.ac_if.if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 894         sc->arpcom.ac_if.if_timer = 0;
 895         sc->arpcom.ac_if.if_output = ether_output;
 896         sc->arpcom.ac_if.if_start = lnc_start;
 897         sc->arpcom.ac_if.if_ioctl = lnc_ioctl;
 898         sc->arpcom.ac_if.if_watchdog = lnc_watchdog;
 899         sc->arpcom.ac_if.if_init = lnc_init;
 900         sc->arpcom.ac_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
 901
 902         /* Extract MAC address from PROM */
 903         for (i = 0; i < ETHER_ADDR_LEN; i++)
 904                 sc->arpcom.ac_enaddr[i] = lnc_inb(i * skip);
 905
 906         /*
 907          * XXX -- should check return status of if_attach
 908          */
 909
 910         ether_ifattach(&sc->arpcom.ac_if, sc->arpcom.ac_enaddr);
 911
 912         printf("lnc%d: ", unit);
 913         if (sc->nic.ic == LANCE || sc->nic.ic == C_LANCE)
 914                 printf("%s (%s)",
 915                        nic_ident[sc->nic.ident], ic_ident[sc->nic.ic]);
 916         else
 917                 printf("%s", ic_ident[sc->nic.ic]);
 918         printf(" address %6D\n", sc->arpcom.ac_enaddr, ":");
 919
 920         return (1);
 921 }
 922
 923 static void
 924 lnc_init(xsc)
 925         void *xsc;
 926 {
 927         struct lnc_softc *sc = xsc;
 928         int s, i;
 929         char *lnc_mem;
 930
 931         /* Check that interface has valid address */
 932
 933         if (TAILQ_EMPTY(&sc->arpcom.ac_if.if_addrhead)) { /* XXX unlikely */
 934 printf("XXX no address?\n");
 935                 return;
 936         }
 937
 938         /* Shut down interface */
 939
 940         s = splimp();
 941         lnc_stop(sc);
 942         sc->arpcom.ac_if.if_flags |= IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; /* XXX??? */
 943
 944         /*
 945          * This sets up the memory area for the controller. Memory is set up for
 946          * the initialisation block (12 words of contiguous memory starting
 947          * on a word boundary),the transmit and receive ring structures (each
 948          * entry is 4 words long and must start on a quadword boundary) and
 949          * the data buffers.
 950          *
 951          * The alignment tests are particularly paranoid.
 952          */
 953
 954         sc->recv_next = 0;
 955         sc->trans_ring = sc->recv_ring + NDESC(sc->nrdre);
 956         sc->trans_next = 0;
 957
 958         if (sc->nic.mem_mode == SHMEM)
 959                 lnc_mem = (char *) sc->nic.iobase;
 960         else
 961                 lnc_mem = (char *) (sc->trans_ring + NDESC(sc->ntdre));
 962
 963         lnc_mem = (char *)(((int)lnc_mem + 1) & ~1);
 964         sc->init_block = (struct init_block *) ((int) lnc_mem & ~1);
 965         lnc_mem = (char *) (sc->init_block + 1);
 966         lnc_mem = (char *)(((int)lnc_mem + 7) & ~7);
 967
 968         /* Initialise pointers to descriptor entries */
 969         for (i = 0; i < NDESC(sc->nrdre); i++) {
 970                 (sc->recv_ring + i)->md = (struct mds *) lnc_mem;
 971                 lnc_mem += sizeof(struct mds);
 972         }
 973         for (i = 0; i < NDESC(sc->ntdre); i++) {
 974                 (sc->trans_ring + i)->md = (struct mds *) lnc_mem;
 975                 lnc_mem += sizeof(struct mds);
 976         }
 977
 978         /* Initialise the remaining ring entries */
 979
 980         if (sc->nic.mem_mode == DMA_MBUF) {
 981
 982                 sc->mbufs = 0;
 983                 sc->mbuf_count = 0;
 984
 985                 /* Free previously allocated mbufs */
 986                 if (sc->flags & LNC_INITIALISED)
 987                         lnc_free_mbufs(sc);
 988
 989
 990                 for (i = 0; i < NDESC(sc->nrdre); i++) {
 991                         if (alloc_mbuf_cluster(sc, sc->recv_ring+i)) {
 992                                 log(LOG_ERR, "Initialisation failed -- no mbufs\n");
 993                                 splx(s);
 994                                 return;
 995                         }
 996                 }
 997
 998                 for (i = 0; i < NDESC(sc->ntdre); i++) {
 999                         (sc->trans_ring + i)->buff.mbuf = 0;
1000                         (sc->trans_ring + i)->md->md0 = 0;
1001                         (sc->trans_ring + i)->md->md1 = 0;
1002                         (sc->trans_ring + i)->md->md2 = 0;
1003                         (sc->trans_ring + i)->md->md3 = 0;
1004                 }
1005         } else {
1006                 for (i = 0; i < NDESC(sc->nrdre); i++) {
1007                         (sc->recv_ring + i)->md->md0 = kvtop(lnc_mem);
1008                         (sc->recv_ring + i)->md->md1 = ((kvtop(lnc_mem) >> 16) & 0xff) | OWN;
1009                         (sc->recv_ring + i)->md->md2 = -RECVBUFSIZE;
1010                         (sc->recv_ring + i)->md->md3 = 0;
1011                         (sc->recv_ring + i)->buff.data = lnc_mem;
1012                         lnc_mem += RECVBUFSIZE;
1013                 }
1014                 for (i = 0; i < NDESC(sc->ntdre); i++) {
1015                         (sc->trans_ring + i)->md->md0 = kvtop(lnc_mem);
1016                         (sc->trans_ring + i)->md->md1 = ((kvtop(lnc_mem) >> 16) & 0xff);
1017                         (sc->trans_ring + i)->md->md2 = 0;
1018                         (sc->trans_ring + i)->md->md3 = 0;
1019                         (sc->trans_ring + i)->buff.data = lnc_mem;
1020                         lnc_mem += TRANSBUFSIZE;
1021                 }
1022         }
1023
1024         sc->next_to_send = 0;
1025
1026         /* Set up initialisation block */
1027
1028         sc->init_block->mode = sc->nic.mode;
1029
1030         for (i = 0; i < ETHER_ADDR_LEN; i++)
1031                 sc->init_block->padr[i] = sc->arpcom.ac_enaddr[i];
1032
1033         lnc_setladrf(sc);
1034
1035         sc->init_block->rdra = kvtop(sc->recv_ring->md);
1036         sc->init_block->rlen = ((kvtop(sc->recv_ring->md) >> 16) & 0xff) | (sc->nrdre << 13);
1037         sc->init_block->tdra = kvtop(sc->trans_ring->md);
1038         sc->init_block->tlen = ((kvtop(sc->trans_ring->md) >> 16) & 0xff) | (sc->ntdre << 13);
1039
1040
1041         /* Set flags to show that the memory area is valid */
1042         sc->flags |= LNC_INITIALISED;
1043
1044         sc->pending_transmits = 0;
1045
1046         /* Give the LANCE the physical address of the initialisation block */
1047
1048         if (sc->nic.ic == PCnet_Home) {
1049                 u_short media;
1050                 /* Set PHY_SEL to HomeRun */
1051                 media = read_bcr(sc, BCR49);
1052                 media &= ~3;
1053                 media |= 1;
1054                 write_bcr(sc, BCR49, media);
1055         }
1056
1057         write_csr(sc, CSR1, kvtop(sc->init_block));
1058         write_csr(sc, CSR2, (kvtop(sc->init_block) >> 16) & 0xff);
1059
1060         /*
1061          * Depending on which controller this is, CSR3 has different meanings.
1062          * For the Am7990 it controls DMA operations, for the Am79C960 it
1063          * controls interrupt masks and transmitter algorithms. In either
1064          * case, none of the flags are set.
1065          *
1066          */
1067
1068         write_csr(sc, CSR3, 0);
1069
1070         /* Let's see if it starts */
1071 /*
1072 printf("Enabling lnc interrupts\n");
1073         sc->arpcom.ac_if.if_timer = 10;
1074         write_csr(sc, CSR0, INIT|INEA);
1075 */
1076
1077         /*
1078          * Now that the initialisation is complete there's no reason to
1079          * access anything except CSR0, so we leave RAP pointing there
1080          * so we can just access RDP from now on, saving an outw each
1081          * time.
1082          */
1083
1084         write_csr(sc, CSR0, INIT);
1085         for(i=0; i < 1000; i++)
1086                 if (read_csr(sc, CSR0) & IDON)
1087                         break;
1088
1089         if (read_csr(sc, CSR0) & IDON) {
1090                 /*
1091                  * Enable interrupts, start the LANCE, mark the interface as
1092                  * running and transmit any pending packets.
1093                  */
1094                 write_csr(sc, CSR0, STRT | INEA);
1095                 sc->arpcom.ac_if.if_flags |= IFF_RUNNING;
1096                 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
1097                 lnc_start(&sc->arpcom.ac_if);
1098         } else
1099                 log(LOG_ERR, "%s: Initialisation failed\n",
1100                     sc->arpcom.ac_if.if_xname);
1101
1102         splx(s);
1103 }
1104
1105 /*
1106  * The interrupt flag (INTR) will be set and provided that the interrupt enable
1107  * flag (INEA) is also set, the interrupt pin will be driven low when any of
1108  * the following occur:
1109  *
1110  * 1) Completion of the initialisation routine (IDON). 2) The reception of a
1111  * packet (RINT). 3) The transmission of a packet (TINT). 4) A transmitter
1112  * timeout error (BABL). 5) A missed packet (MISS). 6) A memory error (MERR).
1113  *
1114  * The interrupt flag is cleared when all of the above conditions are cleared.
1115  *
1116  * If the driver is reset from this routine then it first checks to see if any
1117  * interrupts have ocurred since the reset and handles them before returning.
1118  * This is because the NIC may signify a pending interrupt in CSR0 using the
1119  * INTR flag even if a hardware interrupt is currently inhibited (at least I
1120  * think it does from reading the data sheets). We may as well deal with
1121  * these pending interrupts now rather than get the overhead of another
1122  * hardware interrupt immediately upon returning from the interrupt handler.
1123  *
1124  */
1125
1126 void
1127 lncintr(void *arg)
1128 {
1129         lnc_softc_t *sc = arg;
1130         int unit = sc->arpcom.ac_if.if_dunit;
1131         u_short csr0;
1132
1133         /*
1134          * INEA is the only bit that can be cleared by writing a 0 to it so
1135          * we have to include it in any writes that clear other flags.
1136          */
1137
1138         while ((csr0 = lnc_inw(sc->rdp)) & INTR) {
1139
1140                 /*
1141                  * Clear interrupt flags early to avoid race conditions. The
1142                  * controller can still set these flags even while we're in
1143                  * this interrupt routine. If the flag is still set from the
1144                  * event that caused this interrupt any new events will
1145                  * be missed.
1146                  */
1147
1148                 lnc_outw(sc->rdp, csr0);
1149                 /*lnc_outw(sc->rdp, IDON | CERR | BABL | MISS | MERR | RINT | TINT | INEA);*/
1150
1151 #ifdef notyet
1152                 if (csr0 & IDON) {
1153 printf("IDON\n");
1154                         sc->arpcom.ac_if.if_timer = 0;
1155                         write_csr(sc, CSR0, STRT | INEA);
1156                         sc->arpcom.ac_if.if_flags |= IFF_RUNNING;
1157                         sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
1158                         lnc_start(&sc->arpcom.ac_if);
1159                         continue;
1160                 }
1161 #endif
1162
1163                 if (csr0 & ERR) {
1164                         if (csr0 & CERR) {
1165                                 log(LOG_ERR, "lnc%d: Heartbeat error -- SQE test failed\n", unit);
1166                                 LNCSTATS(cerr)
1167                         }
1168                         if (csr0 & BABL) {
1169                                 log(LOG_ERR, "lnc%d: Babble error - more than 1519 bytes transmitted\n", unit);
1170                                 LNCSTATS(babl)
1171                                 sc->arpcom.ac_if.if_oerrors++;
1172                         }
1173                         if (csr0 & MISS) {
1174                                 log(LOG_ERR, "lnc%d: Missed packet -- no receive buffer\n", unit);
1175                                 LNCSTATS(miss)
1176                                 sc->arpcom.ac_if.if_ierrors++;
1177                         }
1178                         if (csr0 & MERR) {
1179                                 log(LOG_ERR, "lnc%d: Memory error  -- Resetting\n", unit);
1180                                 LNCSTATS(merr)
1181                                 lnc_reset(sc);
1182                                 continue;
1183                         }
1184                 }
1185                 if (csr0 & RINT) {
1186                         LNCSTATS(rint)
1187                         lnc_rint(sc);
1188                 }
1189                 if (csr0 & TINT) {
1190                         LNCSTATS(tint)
1191                         sc->arpcom.ac_if.if_timer = 0;
1192                         lnc_tint(sc);
1193                 }
1194
1195                 /*
1196                  * If there's room in the transmit descriptor ring then queue
1197                  * some more transmit packets.
1198                  */
1199
1200                 if (!(sc->arpcom.ac_if.if_flags & IFF_OACTIVE))
1201                         lnc_start(&sc->arpcom.ac_if);
1202         }
1203 }
1204
1205 static __inline int
1206 mbuf_to_buffer(struct mbuf *m, char *buffer)
1207 {
1208
1209         int len=0;
1210
1211         for( ; m; m = m->m_next) {
1212                 bcopy(mtod(m, caddr_t), buffer, m->m_len);
1213                 buffer += m->m_len;
1214                 len += m->m_len;
1215         }
1216
1217         return(len);
1218 }
1219
1220 static __inline struct mbuf *
1221 chain_to_cluster(struct mbuf *m)
1222 {
1223         struct mbuf *new;
1224
1225         MGET(new, M_DONTWAIT, MT_DATA);
1226         if (new) {
1227                 MCLGET(new, M_DONTWAIT);
1228                 if (new->m_ext.ext_buf) {
1229                         new->m_len = mbuf_to_buffer(m, new->m_data);
1230                         m_freem(m);
1231                         return(new);
1232                 } else
1233                         m_free(new);
1234         }
1235         return(0);
1236 }
1237
1238 /*
1239  * IFF_OACTIVE and IFF_RUNNING are checked in ether_output so it's redundant
1240  * to check them again since we wouldn't have got here if they were not
1241  * appropriately set. This is also called from lnc_init and lncintr but the
1242  * flags should be ok at those points too.
1243  */
1244
1245 static void
1246 lnc_start(struct ifnet *ifp)
1247 {
1248
1249         struct lnc_softc *sc = ifp->if_softc;
1250         struct host_ring_entry *desc;
1251         int tmp;
1252         int end_of_packet;
1253         struct mbuf *head, *m;
1254         int len, chunk;
1255         int addr;
1256         int no_entries_needed;
1257
1258         do {
1259
1260                 IF_DEQUEUE(&sc->arpcom.ac_if.if_snd, head);
1261                 if (!head)
1262                         return;
1263
1264                 if (sc->nic.mem_mode == DMA_MBUF) {
1265
1266                         no_entries_needed = 0;
1267                         for (m=head; m; m = m->m_next)
1268                                 no_entries_needed++;
1269
1270                         /*
1271                          * We try and avoid bcopy as much as possible
1272                          * but there are two cases when we use it.
1273                          *
1274                          * 1) If there are not enough free entries in the ring
1275                          * to hold each mbuf in the chain then compact the
1276                          * chain into a single cluster.
1277                          *
1278                          * 2) The Am7990 and Am79C90 must not have less than
1279                          * 100 bytes in the first descriptor of a chained
1280                          * packet so it's necessary to shuffle the mbuf
1281                          * contents to ensure this.
1282                          */
1283
1284
1285                         if (no_entries_needed > (NDESC(sc->ntdre) - sc->pending_transmits)) {
1286                                 if (!(head = chain_to_cluster(head))) {
1287                                         log(LOG_ERR, "%s: Couldn't get mbuf for transmit packet -- Resetting \n ",ifp->if_xname);
1288                                         lnc_reset(sc);
1289                                         return;
1290                                 }
1291                         } else if ((sc->nic.ic == LANCE) || (sc->nic.ic == C_LANCE)) {
1292                                 if ((head->m_len < 100) && (head->m_next)) {
1293                                         len = 100 - head->m_len;
1294                                         if (M_TRAILINGSPACE(head) < len) {
1295                                                 /*
1296                                                  * Move data to start of data
1297                                                  * area. We assume the first
1298                                                  * mbuf has a packet header
1299                                                  * and is not a cluster.
1300                                                  */
1301                                                 bcopy((caddr_t)head->m_data, (caddr_t)head->m_pktdat, head->m_len);
1302                                                 head->m_data = head->m_pktdat;
1303                                         }
1304                                         m = head->m_next;
1305                                         while (m && (len > 0)) {
1306                                                 chunk = min(len, m->m_len);
1307                                                 bcopy(mtod(m, caddr_t), mtod(head, caddr_t) + head->m_len, chunk);
1308                                                 len -= chunk;
1309                                                 head->m_len += chunk;
1310                                                 m->m_len -= chunk;
1311                                                 m->m_data += chunk;
1312                                                 if (m->m_len <= 0) {
1313                                                         m = m_free(m);
1314                                                         head->m_next = m;
1315                                                 }
1316                                         }
1317                                 }
1318                         }
1319
1320                         tmp = sc->next_to_send;
1321
1322                         /*
1323                          * On entering this loop we know that tmp points to a
1324                          * descriptor with a clear OWN bit.
1325                          */
1326
1327                         desc = sc->trans_ring + tmp;
1328                         len = ETHER_MIN_LEN;
1329                         for (m = head; m; m = m->m_next) {
1330                                 desc->buff.mbuf = m;
1331                                 addr = kvtop(m->m_data);
1332                                 desc->md->md0 = addr;
1333                                 desc->md->md1 = ((addr >> 16) & 0xff);
1334                                 desc->md->md3 = 0;
1335                                 desc->md->md2 = -m->m_len;
1336                                 sc->pending_transmits++;
1337                                 len -= m->m_len;
1338
1339                                 INC_MD_PTR(tmp, sc->ntdre)
1340                                 desc = sc->trans_ring + tmp;
1341                         }
1342
1343                         end_of_packet = tmp;
1344                         DEC_MD_PTR(tmp, sc->ntdre)
1345                         desc = sc->trans_ring + tmp;
1346                         desc->md->md1 |= ENP;
1347
1348                         if (len > 0)
1349                                 desc->md->md2 -= len;
1350
1351                         /*
1352                          * Set OWN bits in reverse order, otherwise the Lance
1353                          * could start sending the packet before all the
1354                          * buffers have been relinquished by the host.
1355                          */
1356
1357                         while (tmp != sc->next_to_send) {
1358                                 desc->md->md1 |= OWN;
1359                                 DEC_MD_PTR(tmp, sc->ntdre)
1360                                 desc = sc->trans_ring + tmp;
1361                         }
1362                         sc->next_to_send = end_of_packet;
1363                         desc->md->md1 |= STP | OWN;
1364                 } else {
1365                         sc->pending_transmits++;
1366                         desc = sc->trans_ring + sc->next_to_send;
1367                         len = mbuf_to_buffer(head, desc->buff.data);
1368                         desc->md->md3 = 0;
1369                         desc->md->md2 = -max(len, ETHER_MIN_LEN - ETHER_CRC_LEN);
1370                         desc->md->md1 |= OWN | STP | ENP;
1371                         INC_MD_PTR(sc->next_to_send, sc->ntdre)
1372                 }
1373
1374                 /* Force an immediate poll of the transmit ring */
1375                 lnc_outw(sc->rdp, TDMD | INEA);
1376
1377                 /*
1378                  * Set a timer so if the buggy Am7990.h shuts
1379                  * down we can wake it up.
1380                  */
1381
1382                 ifp->if_timer = 2;
1383
1384                 if (sc->arpcom.ac_if.if_bpf)
1385                         bpf_mtap(&sc->arpcom.ac_if, head);
1386
1387                 if (sc->nic.mem_mode != DMA_MBUF)
1388                         m_freem(head);
1389
1390         } while (sc->pending_transmits < NDESC(sc->ntdre));
1391
1392         /*
1393          * Transmit ring is full so set IFF_OACTIVE
1394          * since we can't buffer any more packets.
1395          */
1396
1397         sc->arpcom.ac_if.if_flags |= IFF_OACTIVE;
1398         LNCSTATS(trans_ring_full)
1399 }
1400
1401 static int
1402 lnc_ioctl(struct ifnet * ifp, u_long command, caddr_t data, struct ucred *cr)
1403 {
1404
1405         struct lnc_softc *sc = ifp->if_softc;
1406         int s, error = 0;
1407
1408         s = splimp();
1409
1410         switch (command) {
1411         case SIOCSIFADDR:
1412         case SIOCGIFADDR:
1413         case SIOCSIFMTU:
1414                 error = ether_ioctl(ifp, command, data);
1415                 break;
1416
1417         case SIOCSIFFLAGS:
1418 #ifdef DEBUG
1419                 if (ifp->if_flags & IFF_DEBUG)
1420                         sc->lnc_debug = 1;
1421                 else
1422                         sc->lnc_debug = 0;
1423 #endif
1424                 if (ifp->if_flags & IFF_PROMISC) {
1425                         if (!(sc->nic.mode & PROM)) {
1426                                 sc->nic.mode |= PROM;
1427                                 lnc_init(sc);
1428                         }
1429                 } else if (sc->nic.mode & PROM) {
1430                         sc->nic.mode &= ~PROM;
1431                         lnc_init(sc);
1432                 }
1433
1434                 if ((ifp->if_flags & IFF_ALLMULTI) &&
1435                     !(sc->flags & LNC_ALLMULTI)) {
1436                         sc->flags |= LNC_ALLMULTI;
1437                         lnc_init(sc);
1438                 } else if (!(ifp->if_flags & IFF_ALLMULTI) &&
1439                             (sc->flags & LNC_ALLMULTI)) {
1440                         sc->flags &= ~LNC_ALLMULTI;
1441                         lnc_init(sc);
1442                 }
1443
1444                 if ((ifp->if_flags & IFF_UP) == 0 &&
1445                     (ifp->if_flags & IFF_RUNNING) != 0) {
1446                         /*
1447                          * If interface is marked down and it is running,
1448                          * then stop it.
1449                          */
1450                         lnc_stop(sc);
1451                         ifp->if_flags &= ~IFF_RUNNING;
1452                 } else if ((ifp->if_flags & IFF_UP) != 0 &&
1453                            (ifp->if_flags & IFF_RUNNING) == 0) {
1454                         /*
1455                          * If interface is marked up and it is stopped, then
1456                          * start it.
1457                          */
1458                         lnc_init(sc);
1459                 }
1460                 break;
1461         case SIOCADDMULTI:
1462         case SIOCDELMULTI:
1463                 lnc_init(sc);
1464                 error = 0;
1465                 break;
1466         default:
1467                 error = EINVAL;
1468         }
1469         (void) splx(s);
1470         return error;
1471 }
1472
1473 static void
1474 lnc_watchdog(struct ifnet *ifp)
1475 {
1476         log(LOG_ERR, "%s: Device timeout -- Resetting\n", ifp->if_xname);
1477         ifp->if_oerrors++;
1478         lnc_reset(ifp->if_softc);
1479 }
1480
1481 #ifdef DEBUG
1482 void
1483 lnc_dump_state(struct lnc_softc *sc)
1484 {
1485         int             i;
1486
1487         printf("\nDriver/NIC [%d] state dump\n", sc->arpcom.ac_if.if_dunit);
1488         printf("Memory access mode: %b\n", sc->nic.mem_mode, MEM_MODES);
1489         printf("Host memory\n");
1490         printf("-----------\n");
1491
1492         printf("Receive ring: base = %p, next = %p\n",
1493             (void *)sc->recv_ring, (void *)(sc->recv_ring + sc->recv_next));
1494         for (i = 0; i < NDESC(sc->nrdre); i++)
1495                 printf("\t%d:%p md = %p buff = %p\n",
1496                     i, (void *)(sc->recv_ring + i),
1497                     (void *)(sc->recv_ring + i)->md,
1498                     (void *)(sc->recv_ring + i)->buff.data);
1499
1500         printf("Transmit ring: base = %p, next = %p\n",
1501             (void *)sc->trans_ring, (void *)(sc->trans_ring + sc->trans_next));
1502         for (i = 0; i < NDESC(sc->ntdre); i++)
1503                 printf("\t%d:%p md = %p buff = %p\n",
1504                     i, (void *)(sc->trans_ring + i),
1505                     (void *)(sc->trans_ring + i)->md,
1506                     (void *)(sc->trans_ring + i)->buff.data);
1507         printf("Lance memory (may be on host(DMA) or card(SHMEM))\n");
1508         printf("Init block = %p\n", (void *)sc->init_block);
1509         printf("\tmode = %b rlen:rdra = %x:%x tlen:tdra = %x:%x\n",
1510             sc->init_block->mode, INIT_MODE, sc->init_block->rlen,
1511           sc->init_block->rdra, sc->init_block->tlen, sc->init_block->tdra);
1512         printf("Receive descriptor ring\n");
1513         for (i = 0; i < NDESC(sc->nrdre); i++)
1514                 printf("\t%d buffer = 0x%x%x, BCNT = %d,\tMCNT = %u,\tflags = %b\n",
1515                     i, ((sc->recv_ring + i)->md->md1 & HADR),
1516                     (sc->recv_ring + i)->md->md0,
1517                     -(short) (sc->recv_ring + i)->md->md2,
1518                     (sc->recv_ring + i)->md->md3,
1519                     (((sc->recv_ring + i)->md->md1 & ~HADR) >> 8), RECV_MD1);
1520         printf("Transmit descriptor ring\n");
1521         for (i = 0; i < NDESC(sc->ntdre); i++)
1522                 printf("\t%d buffer = 0x%x%x, BCNT = %d,\tflags = %b %b\n",
1523                     i, ((sc->trans_ring + i)->md->md1 & HADR),
1524                     (sc->trans_ring + i)->md->md0,
1525                     -(short) (sc->trans_ring + i)->md->md2,
1526                     ((sc->trans_ring + i)->md->md1 >> 8), TRANS_MD1,
1527                     ((sc->trans_ring + i)->md->md3 >> 10), TRANS_MD3);
1528         printf("\nnext_to_send = %x\n", sc->next_to_send);
1529         printf("\n CSR0 = %b CSR1 = %x CSR2 = %x CSR3 = %x\n\n",
1530             read_csr(sc, CSR0), CSR0_FLAGS, read_csr(sc, CSR1),
1531             read_csr(sc, CSR2), read_csr(sc, CSR3));
1532
1533         /* Set RAP back to CSR0 */
1534         lnc_outw(sc->rap, CSR0);
1535 }
1536
1537 void
1538 mbuf_dump_chain(struct mbuf * m)
1539 {
1540
1541 #define MBUF_FLAGS \
1542         "\20\1M_EXT\2M_PKTHDR\3M_EOR\4UNKNOWN\5M_BCAST\6M_MCAST"
1543
1544         if (!m)
1545                 log(LOG_DEBUG, "m == NULL\n");
1546         do {
1547                 log(LOG_DEBUG, "m = %p\n", (void *)m);
1548                 log(LOG_DEBUG, "m_hdr.mh_next = %p\n",
1549                     (void *)m->m_hdr.mh_next);
1550                 log(LOG_DEBUG, "m_hdr.mh_nextpkt = %p\n",
1551                     (void *)m->m_hdr.mh_nextpkt);
1552                 log(LOG_DEBUG, "m_hdr.mh_len = %d\n", m->m_hdr.mh_len);
1553                 log(LOG_DEBUG, "m_hdr.mh_data = %p\n",
1554                     (void *)m->m_hdr.mh_data);
1555                 log(LOG_DEBUG, "m_hdr.mh_type = %d\n", m->m_hdr.mh_type);
1556                 log(LOG_DEBUG, "m_hdr.mh_flags = %b\n", m->m_hdr.mh_flags,
1557                     MBUF_FLAGS);
1558                 if (!(m->m_hdr.mh_flags & (M_PKTHDR | M_EXT)))
1559                         log(LOG_DEBUG, "M_dat.M_databuf = %p\n",
1560                             (void *)m->M_dat.M_databuf);
1561                 else {
1562                         if (m->m_hdr.mh_flags & M_PKTHDR) {
1563                                 log(LOG_DEBUG, "M_dat.MH.MH_pkthdr.len = %d\n",
1564                                     m->M_dat.MH.MH_pkthdr.len);
1565                                 log(LOG_DEBUG,
1566                                     "M_dat.MH.MH_pkthdr.rcvif = %p\n",
1567                                     (void *)m->M_dat.MH.MH_pkthdr.rcvif);
1568                                 if (!(m->m_hdr.mh_flags & M_EXT))
1569                                         log(LOG_DEBUG,
1570                                             "M_dat.MH.MH_dat.MH_databuf = %p\n",
1571                                         (void *)m->M_dat.MH.MH_dat.MH_databuf);
1572                         }
1573                         if (m->m_hdr.mh_flags & M_EXT) {
1574                                 log(LOG_DEBUG,
1575                                     "M_dat.MH.MH_dat.MH_ext.ext_buff %p\n",
1576                                     (void *)m->M_dat.MH.MH_dat.MH_ext.ext_buf);
1577                                 log(LOG_DEBUG,
1578                                     "M_dat.MH.MH_dat.MH_ext.ext_free %p\n",
1579                                     (void *)m->M_dat.MH.MH_dat.MH_ext.ext_free);
1580                                 log(LOG_DEBUG,
1581                                     "M_dat.MH.MH_dat.MH_ext.ext_size %d\n",
1582                                     m->M_dat.MH.MH_dat.MH_ext.ext_size);
1583                         }
1584                 }
1585         } while ((m = m->m_next) != NULL);
1586 }
1587 #endif