Make all network interrupt service routines MPSAFE part 1/3.
[dragonfly.git] / sys / dev / netif / vx / if_vx.c
1 /*
2  * Copyright (c) 1994 Herb Peyerl <hpeyerl@novatel.ca>
3  * 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  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Herb Peyerl.
16  * 4. The name of Herb Peyerl may not be used to endorse or promote products
17  *    derived from this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  *
30  * $FreeBSD: src/sys/dev/vx/if_vx.c,v 1.25.2.6 2002/02/13 00:43:10 dillon Exp $
31  * $DragonFly: src/sys/dev/netif/vx/if_vx.c,v 1.25 2005/11/28 17:13:44 dillon Exp $
32  *
33  */
34
35 /*
36  * Created from if_ep.c driver by Fred Gray (fgray@rice.edu) to support
37  * the 3c590 family.
38  */
39
40 /*
41  *      Modified from the FreeBSD 1.1.5.1 version by:
42  *                      Andres Vega Garcia
43  *                      INRIA - Sophia Antipolis, France
44  *                      avega@sophia.inria.fr
45  */
46
47 /*
48  *  Promiscuous mode added and interrupt logic slightly changed
49  *  to reduce the number of adapter failures. Transceiver select
50  *  logic changed to use value from EEPROM. Autoconfiguration
51  *  features added.
52  *  Done by:
53  *          Serge Babkin
54  *          Chelindbank (Chelyabinsk, Russia)
55  *          babkin@hq.icb.chel.su
56  */
57
58 #include <sys/param.h>
59 #include <sys/bus.h>
60 #include <sys/systm.h>
61 #include <sys/sockio.h>
62 #include <sys/malloc.h>
63 #include <sys/mbuf.h>
64 #include <sys/socket.h>
65 #include <sys/linker_set.h>
66 #include <sys/module.h>
67 #include <sys/serialize.h>
68 #include <sys/thread2.h>
69
70 #include <net/if.h>
71 #include <net/ifq_var.h>
72
73 #include <net/ethernet.h>
74 #include <net/if_arp.h>
75
76 #include <machine/bus_pio.h>
77 #include <machine/bus.h>
78
79 #include <net/bpf.h>
80
81 #include "if_vxreg.h"
82
83 DECLARE_DUMMY_MODULE(if_vx);
84
85 static struct connector_entry {
86   int bit;
87   const char *name;
88 } conn_tab[VX_CONNECTORS] = {
89 #define CONNECTOR_UTP   0
90   { 0x08, "utp"},
91 #define CONNECTOR_AUI   1
92   { 0x20, "aui"},
93 /* dummy */
94   { 0, "???"},
95 #define CONNECTOR_BNC   3
96   { 0x10, "bnc"},
97 #define CONNECTOR_TX    4
98   { 0x02, "tx"},
99 #define CONNECTOR_FX    5
100   { 0x04, "fx"},
101 #define CONNECTOR_MII   6
102   { 0x40, "mii"},
103   { 0, "???"}
104 };
105
106 /* int vxattach (struct vx_softc *); */
107 static void vxtxstat (struct vx_softc *);
108 static int vxstatus (struct vx_softc *);
109 static void vxinit (void *);
110 static int vxioctl (struct ifnet *, u_long, caddr_t, struct ucred *);
111 static void vxstart (struct ifnet *ifp);
112 static void vxwatchdog (struct ifnet *);
113 static void vxreset (struct vx_softc *);
114 /* void vxstop (struct vx_softc *); */
115 static void vxread (struct vx_softc *);
116 static struct mbuf *vxget (struct vx_softc *, u_int);
117 static void vxmbuffill (void *);
118 static void vxmbuffill_serialized (void *);
119 static void vxmbufempty (struct vx_softc *);
120 static void vxsetfilter (struct vx_softc *);
121 static void vxgetlink (struct vx_softc *);
122 static void vxsetlink (struct vx_softc *);
123 /* int vxbusyeeprom (struct vx_softc *); */
124
125 int
126 vxattach(device_t dev)
127 {
128     struct vx_softc *sc;
129     struct ifnet *ifp;
130     uint8_t eaddr[ETHER_ADDR_LEN];
131     int i;
132
133     sc = device_get_softc(dev);
134
135     callout_init(&sc->vx_timer);
136     GO_WINDOW(0);
137     CSR_WRITE_2(sc, VX_COMMAND, GLOBAL_RESET);
138     VX_BUSY_WAIT;
139
140     ifp = &sc->arpcom.ac_if;
141     if_initname(ifp, device_get_name(dev), device_get_unit(dev));
142
143     vxgetlink(sc);
144
145     /*
146      * Read the station address from the eeprom
147      */
148     GO_WINDOW(0);
149     for (i = 0; i < 3; i++) {
150         int x;
151         if (vxbusyeeprom(sc))
152             return 0;
153         CSR_WRITE_2(sc, VX_W0_EEPROM_COMMAND, EEPROM_CMD_RD
154              | (EEPROM_OEM_ADDR_0 + i));
155         if (vxbusyeeprom(sc))
156             return 0;
157         x = CSR_READ_2(sc, VX_W0_EEPROM_DATA);
158         eaddr[(i << 1)] = x >> 8;
159         eaddr[(i << 1) + 1] = x;
160     }
161
162     ifp->if_mtu = ETHERMTU;
163     ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
164     ifq_set_ready(&ifp->if_snd);
165     ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
166     ifp->if_start = vxstart;
167     ifp->if_ioctl = vxioctl;
168     ifp->if_init = vxinit;
169     ifp->if_watchdog = vxwatchdog;
170     ifp->if_softc = sc;
171
172     ether_ifattach(ifp, eaddr, NULL);
173
174     sc->tx_start_thresh = 20;   /* probably a good starting point. */
175
176     vxstop(sc);
177
178     return 1;
179 }
180
181
182
183 /*
184  * The order in here seems important. Otherwise we may not receive
185  * interrupts. ?!
186  */
187 static void
188 vxinit(xsc)
189         void *xsc;
190 {
191     struct vx_softc *sc = (struct vx_softc *) xsc;
192     struct ifnet *ifp = &sc->arpcom.ac_if;
193     int i;
194
195     VX_BUSY_WAIT;
196
197     GO_WINDOW(2);
198
199     for (i = 0; i < 6; i++) /* Reload the ether_addr. */
200         CSR_WRITE_1(sc, VX_W2_ADDR_0 + i, sc->arpcom.ac_enaddr[i]);
201
202     CSR_WRITE_2(sc, VX_COMMAND, RX_RESET);
203     VX_BUSY_WAIT;
204     CSR_WRITE_2(sc, VX_COMMAND, TX_RESET);
205     VX_BUSY_WAIT;
206
207     GO_WINDOW(1);       /* Window 1 is operating window */
208     for (i = 0; i < 31; i++)
209         CSR_READ_1(sc, VX_W1_TX_STATUS);
210
211     CSR_WRITE_2(sc, VX_COMMAND,SET_RD_0_MASK | S_CARD_FAILURE |
212                         S_RX_COMPLETE | S_TX_COMPLETE | S_TX_AVAIL);
213     CSR_WRITE_2(sc, VX_COMMAND,SET_INTR_MASK | S_CARD_FAILURE |
214                         S_RX_COMPLETE | S_TX_COMPLETE | S_TX_AVAIL);
215
216     /*
217      * Attempt to get rid of any stray interrupts that occured during
218      * configuration.  On the i386 this isn't possible because one may
219      * already be queued.  However, a single stray interrupt is
220      * unimportant.
221      */
222     CSR_WRITE_2(sc, VX_COMMAND, ACK_INTR | 0xff);
223
224     vxsetfilter(sc);
225     vxsetlink(sc);
226
227     CSR_WRITE_2(sc, VX_COMMAND, RX_ENABLE);
228     CSR_WRITE_2(sc, VX_COMMAND, TX_ENABLE);
229
230     vxmbuffill_serialized((caddr_t) sc);
231
232     /* Interface is now `running', with no output active. */
233     ifp->if_flags |= IFF_RUNNING;
234     ifp->if_flags &= ~IFF_OACTIVE;
235
236     /* Attempt to start output, if any. */
237     vxstart(ifp);
238 }
239
240 static void
241 vxsetfilter(sc)
242     struct vx_softc *sc;
243 {
244     struct ifnet *ifp = &sc->arpcom.ac_if;  
245     
246     GO_WINDOW(1);           /* Window 1 is operating window */
247     CSR_WRITE_2(sc, VX_COMMAND, SET_RX_FILTER | FIL_INDIVIDUAL | FIL_BRDCST |
248          FIL_MULTICAST |
249          ((ifp->if_flags & IFF_PROMISC) ? FIL_PROMISC : 0 ));
250 }               
251
252 static void            
253 vxgetlink(sc)
254     struct vx_softc *sc;
255 {
256     int n, k;
257
258     GO_WINDOW(3);
259     sc->vx_connectors = CSR_READ_2(sc, VX_W3_RESET_OPT) & 0x7f;
260     for (n = 0, k = 0; k < VX_CONNECTORS; k++) {
261       if (sc->vx_connectors & conn_tab[k].bit) {
262         if (n == 0)
263           if_printf(&sc->arpcom.ac_if, "%s", conn_tab[k].name);
264         else
265           printf("/%s", conn_tab[k].name);
266         n++;
267       }
268     }
269     if (n == 0) {
270         if_printf(&sc->arpcom.ac_if, "no connectors!\n");
271         return;
272     }
273     GO_WINDOW(3);
274     sc->vx_connector = (CSR_READ_4(sc, VX_W3_INTERNAL_CFG) 
275                         & INTERNAL_CONNECTOR_MASK) 
276                         >> INTERNAL_CONNECTOR_BITS;
277     if (sc->vx_connector & 0x10) {
278         sc->vx_connector &= 0x0f;
279         printf("[*%s*]", conn_tab[(int)sc->vx_connector].name);
280         printf(": disable 'auto select' with DOS util!\n");
281     } else {
282         printf("[*%s*]\n", conn_tab[(int)sc->vx_connector].name);
283     }
284 }
285
286 static void            
287 vxsetlink(sc)
288     struct vx_softc *sc;
289 {       
290     struct ifnet *ifp = &sc->arpcom.ac_if;  
291     int i, j, k;
292     const char *reason, *warning;
293     static short prev_flags;
294     static char prev_conn = -1;
295
296     if (prev_conn == -1) {
297         prev_conn = sc->vx_connector;
298     }
299
300     /*
301      * S.B.
302      *
303      * Now behavior was slightly changed:
304      *
305      * if any of flags link[0-2] is used and its connector is
306      * physically present the following connectors are used:
307      *
308      *   link0 - AUI * highest precedence
309      *   link1 - BNC
310      *   link2 - UTP * lowest precedence
311      *
312      * If none of them is specified then
313      * connector specified in the EEPROM is used
314      * (if present on card or UTP if not).
315      */
316
317     i = sc->vx_connector;       /* default in EEPROM */
318     reason = "default";
319     warning = NULL;
320
321     if (ifp->if_flags & IFF_LINK0) {
322         if (sc->vx_connectors & conn_tab[CONNECTOR_AUI].bit) {
323             i = CONNECTOR_AUI;
324             reason = "link0";
325         } else {
326             warning = "aui not present! (link0)";
327         }
328     } else if (ifp->if_flags & IFF_LINK1) {
329         if (sc->vx_connectors & conn_tab[CONNECTOR_BNC].bit) {
330             i = CONNECTOR_BNC;
331             reason = "link1";
332         } else {
333             warning = "bnc not present! (link1)";
334         }
335     } else if (ifp->if_flags & IFF_LINK2) {
336         if (sc->vx_connectors & conn_tab[CONNECTOR_UTP].bit) {
337             i = CONNECTOR_UTP;
338             reason = "link2";
339         } else {
340             warning = "utp not present! (link2)";
341         }
342     } else if ((sc->vx_connectors & conn_tab[(int)sc->vx_connector].bit) == 0) {
343         warning = "strange connector type in EEPROM.";
344         reason = "forced";
345         i = CONNECTOR_UTP;
346     }
347
348     /* Avoid unnecessary message. */
349     k = (prev_flags ^ ifp->if_flags) & (IFF_LINK0 | IFF_LINK1 | IFF_LINK2);
350     if ((k != 0) || (prev_conn != i)) {
351         if (warning != NULL) {
352             if_printf(ifp, "warning: %s\n", warning);
353         }
354         if_printf(ifp, "selected %s. (%s)\n", conn_tab[i].name, reason);
355     }
356
357     /* Set the selected connector. */
358     GO_WINDOW(3);
359     j = CSR_READ_4(sc, VX_W3_INTERNAL_CFG) & ~INTERNAL_CONNECTOR_MASK;
360     CSR_WRITE_4(sc, VX_W3_INTERNAL_CFG, j | (i <<INTERNAL_CONNECTOR_BITS));
361
362     /* First, disable all. */
363     CSR_WRITE_2(sc,VX_COMMAND, STOP_TRANSCEIVER);
364     DELAY(800);
365     GO_WINDOW(4);
366     CSR_WRITE_2(sc, VX_W4_MEDIA_TYPE, 0);
367
368     /* Second, enable the selected one. */
369     switch(i) {
370       case CONNECTOR_UTP:
371         GO_WINDOW(4);
372         CSR_WRITE_2(sc, VX_W4_MEDIA_TYPE, ENABLE_UTP);
373         break;
374       case CONNECTOR_BNC:
375         CSR_WRITE_2(sc, VX_COMMAND, START_TRANSCEIVER);
376         DELAY(800);
377         break;
378       case CONNECTOR_TX:
379       case CONNECTOR_FX:
380         GO_WINDOW(4);
381         CSR_WRITE_2(sc, VX_W4_MEDIA_TYPE, LINKBEAT_ENABLE);
382         break;
383       default:  /* AUI and MII fall here */
384         break;
385     }
386     GO_WINDOW(1); 
387
388     prev_flags = ifp->if_flags;
389     prev_conn = i;
390 }
391
392 static void
393 vxstart(ifp)
394     struct ifnet *ifp;
395 {
396     struct vx_softc *sc = ifp->if_softc;
397     struct mbuf *m0;
398     int len, pad;
399
400     /* Don't transmit if interface is busy or not running */
401     if ((ifp->if_flags & (IFF_RUNNING|IFF_OACTIVE)) != IFF_RUNNING)
402         return;
403
404 startagain:
405     /* Sneak a peek at the next packet */
406     m0 = ifq_poll(&ifp->if_snd);
407     if (m0 == NULL)
408         return;
409     /* We need to use m->m_pkthdr.len, so require the header */
410      M_ASSERTPKTHDR(m0);
411      len = m0->m_pkthdr.len;
412
413      pad = (4 - len) & 3;
414
415     /*
416      * The 3c509 automatically pads short packets to minimum ethernet length,
417      * but we drop packets that are too large. Perhaps we should truncate
418      * them instead?
419      */
420     if (len + pad > ETHER_MAX_LEN) {
421         /* packet is obviously too large: toss it */
422         ++ifp->if_oerrors;
423         ifq_dequeue(&ifp->if_snd, m0);
424         m_freem(m0);
425         goto readcheck;
426     }
427     VX_BUSY_WAIT;
428     if (CSR_READ_2(sc, VX_W1_FREE_TX) < len + pad + 4) {
429         CSR_WRITE_2(sc, VX_COMMAND, SET_TX_AVAIL_THRESH | ((len + pad + 4) >> 2));
430         /* not enough room in FIFO */
431         if (CSR_READ_2(sc, VX_W1_FREE_TX) < len + pad + 4) { /* make sure */
432             ifp->if_flags |= IFF_OACTIVE;
433             ifp->if_timer = 1;
434             return;
435         }
436     }
437     CSR_WRITE_2(sc, VX_COMMAND, SET_TX_AVAIL_THRESH | (8188 >> 2));
438     ifq_dequeue(&ifp->if_snd, m0);
439
440     VX_BUSY_WAIT;
441     CSR_WRITE_2(sc, VX_COMMAND, SET_TX_START_THRESH |
442         ((len / 4 + sc->tx_start_thresh) >> 2));
443
444     BPF_MTAP(ifp, m0);
445
446     /*
447      * Do the output in a critical section so that an interrupt from
448      * another device won't cause a FIFO underrun.
449      */
450     crit_enter();
451
452     CSR_WRITE_4(sc, VX_W1_TX_PIO_WR_1, len | TX_INDICATE);
453
454     while (m0) {
455         if (m0->m_len > 3)
456             bus_space_write_multi_4(sc->vx_btag, sc->vx_bhandle,
457                 VX_W1_TX_PIO_WR_1,
458                 (u_int32_t *)mtod(m0, caddr_t), m0->m_len / 4);
459         if (m0->m_len & 3)
460             bus_space_write_multi_1(sc->vx_btag, sc->vx_bhandle,
461                 VX_W1_TX_PIO_WR_1,
462                 mtod(m0, caddr_t) + (m0->m_len & ~3), m0->m_len & 3);
463         m0 = m_free(m0);
464     }
465     while (pad--)
466         CSR_WRITE_1(sc, VX_W1_TX_PIO_WR_1, 0);  /* Padding */
467
468     crit_exit();
469
470     ++ifp->if_opackets;
471     ifp->if_timer = 1;
472
473 readcheck:
474     if ((CSR_READ_2(sc, VX_W1_RX_STATUS) & ERR_INCOMPLETE) == 0) {
475         /* We received a complete packet. */
476         
477         if ((CSR_READ_2(sc, VX_STATUS) & S_INTR_LATCH) != 0) {
478             /* Got an interrupt, return so that it gets serviced. */
479             return;
480         }
481         /*
482          * No interrupt, read the packet and continue
483          * Is  this supposed to happen? Is my motherboard
484          * completely busted?
485          */
486         vxread(sc);
487     } else {
488         /* Check if we are stuck and reset [see XXX comment] */
489         if (vxstatus(sc)) {
490             if (ifp->if_flags & IFF_DEBUG)
491                if_printf(ifp, "adapter reset\n");
492             vxreset(sc);
493         }
494     }
495
496     goto startagain;
497 }
498
499 /*
500  * XXX: The 3c509 card can get in a mode where both the fifo status bit
501  *      FIFOS_RX_OVERRUN and the status bit ERR_INCOMPLETE are set
502  *      We detect this situation and we reset the adapter.
503  *      It happens at times when there is a lot of broadcast traffic
504  *      on the cable (once in a blue moon).
505  */
506 static int
507 vxstatus(sc)
508     struct vx_softc *sc;
509 {
510     int fifost;
511     struct ifnet *ifp = &sc->arpcom.ac_if;
512
513     /*
514      * Check the FIFO status and act accordingly
515      */
516     GO_WINDOW(4);
517     fifost = CSR_READ_2(sc, VX_W4_FIFO_DIAG);
518     GO_WINDOW(1);
519
520     if (fifost & FIFOS_RX_UNDERRUN) {
521         if (ifp->if_flags & IFF_DEBUG)
522             if_printf(ifp, "RX underrun\n");
523         vxreset(sc);
524         return 0;
525     }
526
527     if (fifost & FIFOS_RX_STATUS_OVERRUN) {
528         if (ifp->if_flags & IFF_DEBUG)
529             if_printf(ifp, "RX Status overrun\n");
530         return 1;
531     }
532
533     if (fifost & FIFOS_RX_OVERRUN) {
534         if (ifp->if_flags & IFF_DEBUG)
535             if_printf(ifp, "RX overrun\n");
536         return 1;
537     }
538
539     if (fifost & FIFOS_TX_OVERRUN) {
540         if (ifp->if_flags & IFF_DEBUG)
541             if_printf(ifp, "TX overrun\n");
542         vxreset(sc);
543     }
544
545     return 0;
546 }
547
548 static void     
549 vxtxstat(struct vx_softc *sc)
550 {
551         int i;
552         struct ifnet *ifp = &sc->arpcom.ac_if;
553
554         /*
555          * We need to read+write TX_STATUS until we get a 0 status
556          * in order to turn off the interrupt flag.
557          */
558         while ((i = CSR_READ_1(sc, VX_W1_TX_STATUS)) & TXS_COMPLETE) {
559                 CSR_WRITE_1(sc, VX_W1_TX_STATUS, 0x0);
560
561                 if (i & TXS_JABBER) {
562                         ++ifp->if_oerrors;
563                         if (ifp->if_flags & IFF_DEBUG)
564                                 if_printf(ifp, "jabber (%x)\n", i);
565                         vxreset(sc);
566                 } else if (i & TXS_UNDERRUN) {
567                         ++ifp->if_oerrors;
568                         if (ifp->if_flags & IFF_DEBUG) {
569                                 if_printf(ifp, "fifo underrun (%x) @%d\n",
570                                           i, sc->tx_start_thresh);
571                         }
572                         if (sc->tx_succ_ok < 100) {
573                                 sc->tx_start_thresh = min(
574                                     ETHER_MAX_LEN, sc->tx_start_thresh + 20);
575                         }
576                         sc->tx_succ_ok = 0;
577                         vxreset(sc);
578                 } else if (i & TXS_MAX_COLLISION) {
579                         ++ifp->if_collisions;
580                         CSR_WRITE_2(sc, VX_COMMAND, TX_ENABLE);
581                         ifp->if_flags &= ~IFF_OACTIVE;
582                 } else {
583                         sc->tx_succ_ok = (sc->tx_succ_ok+1) & 127;
584                 }
585         }
586 }
587
588 void
589 vxintr(voidsc)
590     void *voidsc;
591 {
592     short status;
593     struct vx_softc *sc = voidsc;
594     struct ifnet *ifp = &sc->arpcom.ac_if;
595
596     for (;;) {
597         CSR_WRITE_2(sc, VX_COMMAND, C_INTR_LATCH);
598
599         status = CSR_READ_2(sc, VX_STATUS);
600
601         if ((status & (S_TX_COMPLETE | S_TX_AVAIL |
602                 S_RX_COMPLETE | S_CARD_FAILURE)) == 0)
603             break;
604
605         /*
606          * Acknowledge any interrupts.  It's important that we do this
607          * first, since there would otherwise be a race condition.
608          * Due to the i386 interrupt queueing, we may get spurious
609          * interrupts occasionally.
610          */
611         CSR_WRITE_2(sc, VX_COMMAND, ACK_INTR | status);
612
613         if (status & S_RX_COMPLETE)
614             vxread(sc);
615         if (status & S_TX_AVAIL) {
616             ifp->if_timer = 0;
617             ifp->if_flags &= ~IFF_OACTIVE;
618             vxstart(ifp);
619         }
620         if (status & S_CARD_FAILURE) {
621             if_printf(ifp, "adapter failure (%x)\n", status);
622             ifp->if_timer = 0;
623             vxreset(sc);
624             return;
625         }
626         if (status & S_TX_COMPLETE) {
627             ifp->if_timer = 0;
628             vxtxstat(sc);
629             vxstart(ifp);
630         }
631     }
632     /* no more interrupts */
633 }
634
635 static void
636 vxread(sc)
637     struct vx_softc *sc;
638 {
639     struct ifnet *ifp = &sc->arpcom.ac_if;
640     struct mbuf *m;
641     struct ether_header *eh;
642     u_int len;
643
644     len = CSR_READ_2(sc, VX_W1_RX_STATUS);
645
646 again:
647
648     if (ifp->if_flags & IFF_DEBUG) {
649         int err = len & ERR_MASK;
650         const char *s = NULL;
651
652         if (len & ERR_INCOMPLETE)
653             s = "incomplete packet";
654         else if (err == ERR_OVERRUN)
655             s = "packet overrun";
656         else if (err == ERR_RUNT)
657             s = "runt packet";
658         else if (err == ERR_ALIGNMENT)
659             s = "bad alignment";
660         else if (err == ERR_CRC)
661             s = "bad crc";
662         else if (err == ERR_OVERSIZE)
663             s = "oversized packet";
664         else if (err == ERR_DRIBBLE)
665             s = "dribble bits";
666
667         if (s)
668             if_printf(ifp, "%s\n", s);
669     }
670
671     if (len & ERR_INCOMPLETE)
672         return;
673
674     if (len & ERR_RX) {
675         ++ifp->if_ierrors;
676         goto abort;
677     }
678
679     len &= RX_BYTES_MASK;       /* Lower 11 bits = RX bytes. */
680
681     /* Pull packet off interface. */
682     m = vxget(sc, len);
683     if (m == NULL) {
684         ifp->if_ierrors++;
685         goto abort;
686     }
687
688     ++ifp->if_ipackets;
689
690     /* We assume the header fit entirely in one mbuf. */
691     eh = mtod(m, struct ether_header *);
692
693     /*
694      * XXX: Some cards seem to be in promiscous mode all the time.
695      * we need to make sure we only get our own stuff always.
696      * bleah!
697      */
698
699     if ((eh->ether_dhost[0] & 1) == 0           /* !mcast and !bcast */
700       && bcmp(eh->ether_dhost, sc->arpcom.ac_enaddr, ETHER_ADDR_LEN) != 0) {
701         m_freem(m);
702         return;
703     }
704
705     ifp->if_input(ifp, m);
706
707     /*
708     * In periods of high traffic we can actually receive enough
709     * packets so that the fifo overrun bit will be set at this point,
710     * even though we just read a packet. In this case we
711     * are not going to receive any more interrupts. We check for
712     * this condition and read again until the fifo is not full.
713     * We could simplify this test by not using vxstatus(), but
714     * rechecking the RX_STATUS register directly. This test could
715     * result in unnecessary looping in cases where there is a new
716     * packet but the fifo is not full, but it will not fix the
717     * stuck behavior.
718     *
719     * Even with this improvement, we still get packet overrun errors
720     * which are hurting performance. Maybe when I get some more time
721     * I'll modify vxread() so that it can handle RX_EARLY interrupts.
722     */
723     if (vxstatus(sc)) {
724         len = CSR_READ_2(sc, VX_W1_RX_STATUS);
725         /* Check if we are stuck and reset [see XXX comment] */
726         if (len & ERR_INCOMPLETE) {
727             if (ifp->if_flags & IFF_DEBUG)
728                 if_printf(ifp, "adapter reset\n");
729             vxreset(sc);
730             return;
731         }
732         goto again;
733     }
734
735     return;
736
737 abort:
738     CSR_WRITE_2(sc, VX_COMMAND, RX_DISCARD_TOP_PACK);
739 }
740
741 static struct mbuf *
742 vxget(sc, totlen)
743     struct vx_softc *sc;
744     u_int totlen;
745 {
746     struct ifnet *ifp = &sc->arpcom.ac_if;
747     struct mbuf *top, **mp, *m;
748     int len;
749
750     m = sc->mb[sc->next_mb];
751     sc->mb[sc->next_mb] = NULL;
752     if (m == NULL) {
753         MGETHDR(m, MB_DONTWAIT, MT_DATA);
754         if (m == NULL)
755             return NULL;
756     } else {
757         /* If the queue is no longer full, refill. */
758         if (sc->last_mb == sc->next_mb && sc->buffill_pending == 0) {
759             callout_reset(&sc->vx_timer, 1, vxmbuffill, sc);
760             sc->buffill_pending = 1;
761         }
762         /* Convert one of our saved mbuf's. */
763         sc->next_mb = (sc->next_mb + 1) % MAX_MBS;
764         m->m_data = m->m_pktdat;
765         m->m_flags = M_PKTHDR;
766         bzero(&m->m_pkthdr, sizeof(m->m_pkthdr));
767     }
768     m->m_pkthdr.rcvif = ifp;
769     m->m_pkthdr.len = totlen;
770     len = MHLEN;
771     top = NULL;
772     mp = &top;
773
774     /*
775      * We read the packet in a critical section so that an interrupt
776      * from another device doesn't cause the card's buffer to overflow
777      * while we're reading it.  We may still lose packets at other times.
778      */
779     crit_enter();
780
781     /*
782      * Since we don't set allowLargePackets bit in MacControl register,
783      * we can assume that totlen <= 1500bytes.
784      * The while loop will be performed if we have a packet with
785      * MLEN < m_len < MINCLSIZE.
786      */
787     while (totlen > 0) {
788         if (top) {
789             m = sc->mb[sc->next_mb];
790             sc->mb[sc->next_mb] = NULL;
791             if (m == NULL) {
792                 MGET(m, MB_DONTWAIT, MT_DATA);
793                 if (m == NULL) {
794                     crit_exit();
795                     m_freem(top);
796                     return NULL;
797                 }
798             } else {
799                 sc->next_mb = (sc->next_mb + 1) % MAX_MBS;
800             }
801             len = MLEN;
802         }
803         if (totlen >= MINCLSIZE) {
804             MCLGET(m, MB_DONTWAIT);
805             if (m->m_flags & M_EXT)
806                 len = MCLBYTES;
807         }
808         len = min(totlen, len);
809         if (len > 3)
810             bus_space_read_multi_4(sc->vx_btag, sc->vx_bhandle,
811                 VX_W1_RX_PIO_RD_1, mtod(m, u_int32_t *), len / 4);
812         if (len & 3) {
813             bus_space_read_multi_1(sc->vx_btag, sc->vx_bhandle,
814                 VX_W1_RX_PIO_RD_1, mtod(m, u_int8_t *) + (len & ~3),
815                 len & 3);
816         }
817         m->m_len = len;
818         totlen -= len;
819         *mp = m;
820         mp = &m->m_next;
821     }
822
823     CSR_WRITE_2(sc, VX_COMMAND, RX_DISCARD_TOP_PACK);
824
825     crit_exit();
826
827     return top;
828 }
829
830
831 static int
832 vxioctl(ifp, cmd, data, cr)
833     struct ifnet *ifp;
834     u_long cmd;
835     caddr_t data;
836     struct ucred *cr;
837 {
838     struct vx_softc *sc = ifp->if_softc;
839     struct ifreq *ifr = (struct ifreq *) data;
840     int error = 0;
841
842     switch (cmd) {
843     case SIOCSIFFLAGS:
844         if ((ifp->if_flags & IFF_UP) == 0 &&
845             (ifp->if_flags & IFF_RUNNING) != 0) {
846             /*
847              * If interface is marked up and it is stopped, then
848              * start it.
849              */
850             vxstop(sc);
851             ifp->if_flags &= ~IFF_RUNNING;
852         } else if ((ifp->if_flags & IFF_UP) != 0 &&
853                    (ifp->if_flags & IFF_RUNNING) == 0) {
854             /*
855              * If interface is marked up and it is stopped, then
856              * start it.
857              */
858             vxinit(sc);
859         } else {
860             /*
861              * deal with flags changes:
862              * IFF_MULTICAST, IFF_PROMISC,
863              * IFF_LINK0, IFF_LINK1,
864              */
865             vxsetfilter(sc);
866             vxsetlink(sc);
867         }
868         break;
869
870     case SIOCSIFMTU:
871         /*
872          * Set the interface MTU.
873          */
874         if (ifr->ifr_mtu > ETHERMTU) {
875             error = EINVAL;
876         } else {
877             ifp->if_mtu = ifr->ifr_mtu;
878         }
879         break;
880
881     case SIOCADDMULTI:
882     case SIOCDELMULTI:
883         /*
884          * Multicast list has changed; set the hardware filter
885          * accordingly.
886          */
887         vxreset(sc);
888         error = 0;
889         break;
890
891
892     default:
893         ether_ioctl(ifp, cmd, data);
894         break;
895     }
896     return (error);
897 }
898
899 static void
900 vxreset(sc)
901     struct vx_softc *sc;
902 {
903     vxstop(sc);
904     vxinit(sc);
905 }
906
907 static void
908 vxwatchdog(ifp)
909     struct ifnet *ifp;
910 {
911     struct vx_softc *sc = ifp->if_softc;
912
913     if (ifp->if_flags & IFF_DEBUG)
914         if_printf(ifp, "device timeout\n");
915     ifp->if_flags &= ~IFF_OACTIVE;
916     vxstart(ifp);
917     vxintr(sc);
918 }
919
920 void
921 vxstop(sc)
922     struct vx_softc *sc;
923 {
924     struct ifnet *ifp = &sc->arpcom.ac_if;
925
926     ifp->if_timer = 0;
927
928     CSR_WRITE_2(sc, VX_COMMAND, RX_DISABLE);
929     CSR_WRITE_2(sc, VX_COMMAND, RX_DISCARD_TOP_PACK);
930     VX_BUSY_WAIT;
931     CSR_WRITE_2(sc, VX_COMMAND, TX_DISABLE);
932     CSR_WRITE_2(sc, VX_COMMAND, STOP_TRANSCEIVER);
933     DELAY(800);
934     CSR_WRITE_2(sc, VX_COMMAND, RX_RESET);
935     VX_BUSY_WAIT;
936     CSR_WRITE_2(sc, VX_COMMAND, TX_RESET);
937     VX_BUSY_WAIT;
938     CSR_WRITE_2(sc, VX_COMMAND, C_INTR_LATCH);
939     CSR_WRITE_2(sc, VX_COMMAND, SET_RD_0_MASK);
940     CSR_WRITE_2(sc, VX_COMMAND, SET_INTR_MASK);
941     CSR_WRITE_2(sc, VX_COMMAND, SET_RX_FILTER);
942
943     vxmbufempty(sc);
944 }
945
946 int
947 vxbusyeeprom(sc)
948     struct vx_softc *sc;
949 {
950     int j, i = 100;
951
952     while (i--) {
953         j = CSR_READ_2(sc, VX_W0_EEPROM_COMMAND);
954         if (j & EEPROM_BUSY)
955             DELAY(100);
956         else
957             break;
958     }
959     if (!i) {
960         if_printf(&sc->arpcom.ac_if, "eeprom failed to come ready\n");
961         return (1);
962     }
963     return (0);
964 }
965
966 static void
967 vxmbuffill(void *sp)
968 {
969     struct vx_softc *sc = (struct vx_softc *) sp;
970     struct ifnet *ifp = &sc->arpcom.ac_if;
971
972     lwkt_serialize_enter(ifp->if_serializer);
973     vxmbuffill_serialized(sp);
974     lwkt_serialize_exit(ifp->if_serializer);
975 }
976
977 static void
978 vxmbuffill_serialized(void *sp)
979 {
980     struct vx_softc *sc = (struct vx_softc *) sp;
981     int i;
982
983     i = sc->last_mb;
984     do {
985         if (sc->mb[i] == NULL)
986             MGET(sc->mb[i], MB_DONTWAIT, MT_DATA);
987         if (sc->mb[i] == NULL)
988             break;
989         i = (i + 1) % MAX_MBS;
990     } while (i != sc->next_mb);
991     sc->last_mb = i;
992     /* If the queue was not filled, try again. */
993     if (sc->last_mb != sc->next_mb) {
994         callout_reset(&sc->vx_timer, 1, vxmbuffill, sc);
995         sc->buffill_pending = 1;
996     } else {
997         sc->buffill_pending = 0;
998     }
999 }
1000
1001 static void
1002 vxmbufempty(sc)
1003     struct vx_softc *sc;
1004 {
1005     int i;
1006
1007     for (i = 0; i < MAX_MBS; i++) {
1008         if (sc->mb[i]) {
1009             m_freem(sc->mb[i]);
1010             sc->mb[i] = NULL;
1011         }
1012     }
1013     sc->last_mb = sc->next_mb = 0;
1014     if (sc->buffill_pending != 0)
1015         callout_stop(&sc->vx_timer);
1016 }