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