1 /* $NetBSD: smc90cx6.c,v 1.38 2001/07/07 15:57:53 thorpej Exp $ */
5 * Copyright (c) 1994, 1995, 1998 The NetBSD Foundation, Inc.
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Ignatios Souvatzis.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
41 * Chip core driver for the SMC90c26 / SMC90c56 (and SMC90c66 in '56
42 * compatibility mode) boards
45 /* #define CMSOFTCOPY */
46 #define CMRETRANSMIT /**/
49 #include <sys/param.h>
50 #include <sys/systm.h>
51 #include <sys/sockio.h>
53 #include <sys/module.h>
54 #include <sys/kernel.h>
55 #include <sys/socket.h>
56 #include <sys/syslog.h>
59 #include <machine/bus.h>
61 #include <machine/resource.h>
63 #if __FreeBSD_version < 500000
64 #include <machine/clock.h>
68 #include <net/if_dl.h>
69 #include <net/if_types.h>
70 #include <net/if_arc.h>
75 #include <net/bpfdesc.h>
79 #include <dev/cm/smc90cx6reg.h>
80 #include <dev/cm/smc90cx6var.h>
82 MODULE_DEPEND(if_cm, arcnet, 1, 1, 1);
84 /* these should be elsewhere */
87 #define ARC_MIN_FORBID_LEN 254
88 #define ARC_MAX_FORBID_LEN 256
89 #define ARC_MAX_LEN 508
90 #define ARC_ADDR_LEN 1
92 /* for watchdog timer. This should be more than enough. */
93 #define ARCTIMEOUT (5*IFNET_SLOWHZ)
98 bus_space_read_1(rman_get_bustag((sc)->port_res), \
99 rman_get_bushandle((sc)->port_res), \
101 #define PUTREG(off, value) \
102 bus_space_write_1(rman_get_bustag((sc)->port_res), \
103 rman_get_bushandle((sc)->port_res), \
105 #define GETMEM(off) \
106 bus_space_read_1(rman_get_bustag((sc)->mem_res), \
107 rman_get_bushandle((sc)->mem_res), \
109 #define PUTMEM(off, value) \
110 bus_space_write_1(rman_get_bustag((sc)->mem_res), \
111 rman_get_bushandle((sc)->mem_res), \
114 devclass_t cm_devclass;
117 * This currently uses 2 bufs for tx, 2 for rx
121 * rx has a fillcount variable. If fillcount > (NRXBUF-1),
122 * rx can be switched off from rx hard int.
123 * Else rx is restarted on the other receiver.
124 * rx soft int counts down. if it is == (NRXBUF-1), it restarts
126 * To ensure packet ordering (we need that for 1201 later), we have a counter
127 * which is incremented modulo 256 on each receive and a per buffer
128 * variable, which is set to the counter on filling. The soft int can
129 * compare both values to determine the older packet.
131 * Transmit direction:
133 * cm_start checks tx_fillcount
136 * else fill tx_act ^ 1 && inc tx_fillcount
138 * check tx_fillcount again.
139 * case 2: set IFF_OACTIVE to stop arc_output from filling us.
142 * tint clears IFF_OCATIVE, decrements and checks tx_fillcount
143 * case 1: start tx on tx_act ^ 1, softcall cm_start
144 * case 0: softcall cm_start
146 * #define fill(i) get mbuf && copy mbuf to chip(i)
149 void cm_init(void *);
150 void cm_reset(struct cm_softc *);
151 void cm_start(struct ifnet *);
152 int cm_ioctl(struct ifnet *, unsigned long, caddr_t);
153 void cm_watchdog(struct ifnet *);
154 void cm_srint(void *vsc);
155 static void cm_tint(struct cm_softc *, int);
156 void cm_reconwatch(void *);
163 struct cm_softc *sc = device_get_softc(dev);
165 error = cm_alloc_port(dev, 0, CM_IO_PORTS);
169 if (GETREG(CMSTAT) == 0xff)
172 error = cm_alloc_memory(dev, 0, 0x800);
180 * Allocate a port resource with the given resource id.
183 cm_alloc_port(dev, rid, size)
188 struct cm_softc *sc = device_get_softc(dev);
189 struct resource *res;
191 res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
192 0ul, ~0ul, size, RF_ACTIVE);
196 sc->port_used = size;
204 * Allocate a memory resource with the given resource id.
207 cm_alloc_memory(dev, rid, size)
212 struct cm_softc *sc = device_get_softc(dev);
213 struct resource *res;
215 res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid,
216 0ul, ~0ul, size, RF_ACTIVE);
228 * Allocate an irq resource with the given resource id.
231 cm_alloc_irq(dev, rid)
235 struct cm_softc *sc = device_get_softc(dev);
236 struct resource *res;
238 res = bus_alloc_resource(dev, SYS_RES_IRQ, &rid,
239 0ul, ~0ul, 1, RF_ACTIVE);
250 * Release all resources
253 cm_release_resources(dev)
256 struct cm_softc *sc = device_get_softc(dev);
259 bus_deactivate_resource(dev, SYS_RES_IOPORT,
260 sc->port_rid, sc->port_res);
261 bus_release_resource(dev, SYS_RES_IOPORT,
262 sc->port_rid, sc->port_res);
266 bus_deactivate_resource(dev, SYS_RES_MEMORY,
267 sc->mem_rid, sc->mem_res);
268 bus_release_resource(dev, SYS_RES_MEMORY,
269 sc->mem_rid, sc->mem_res);
273 bus_deactivate_resource(dev, SYS_RES_IRQ,
274 sc->irq_rid, sc->irq_res);
275 bus_release_resource(dev, SYS_RES_IRQ,
276 sc->irq_rid, sc->irq_res);
286 struct ifnet *ifp = &sc->sc_arccom.ac_if;
288 u_int8_t linkaddress;
293 * read the arcnet address from the board
299 } while (!(GETREG(CMSTAT) & CM_POR));
301 linkaddress = GETMEM(CMMACOFF);
303 /* clear the int mask... */
308 PUTREG(CMCMD, CM_CONF(CONF_LONG));
309 PUTREG(CMCMD, CM_CLR(CLR_POR|CLR_RECONFIG));
310 sc->sc_recontime = sc->sc_reconcount = 0;
312 /* and reenable kernel int level */
316 * set interface to stopped condition (reset)
324 ifp->if_output = arc_output;
325 ifp->if_start = cm_start;
326 ifp->if_ioctl = cm_ioctl;
327 ifp->if_watchdog = cm_watchdog;
328 ifp->if_init = cm_init;
329 /* XXX IFQ_SET_READY(&ifp->if_snd); */
330 ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
332 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
334 arc_ifattach(ifp, linkaddress);
337 sc->sc_rxcookie = softintr_establish(IPL_SOFTNET, cm_srint, sc);
338 sc->sc_txcookie = softintr_establish(IPL_SOFTNET,
339 (void (*)(void *))cm_start, ifp);
342 #if __FreeBSD_version < 500000
343 callout_init(&sc->sc_recon_ch);
345 callout_init(&sc->sc_recon_ch, 0);
349 printf("%s%d: link addr 0x%02x(%d)\n",
350 ifp->if_name, ifp->if_unit, linkaddress, linkaddress);
362 struct cm_softc *sc = (struct cm_softc *)xsc;
366 ifp = &sc->sc_arccom.ac_if;
368 if ((ifp->if_flags & IFF_RUNNING) == 0) {
370 ifp->if_flags |= IFF_RUNNING;
378 * Reset the interface...
380 * this assumes that it is called inside a critical section...
390 ifp = &sc->sc_arccom.ac_if;
393 printf("%s%d: reset\n", ifp->if_name, ifp->if_unit);
395 /* stop and restart hardware */
400 } while (!(GETREG(CMSTAT) & CM_POR));
402 linkaddress = GETMEM(CMMACOFF);
404 #if defined(CM_DEBUG) && (CM_DEBUG > 2)
405 printf("%s%d: reset: card reset, link addr = 0x%02x (%d)\n",
406 ifp->if_name, ifp->if_unit, linkaddress, linkaddress);
409 /* tell the routing level about the (possibly changed) link address */
410 arc_storelladdr(ifp, linkaddress);
413 /* POR is NMI, but we need it below: */
414 sc->sc_intmask = CM_RECON|CM_POR;
415 PUTREG(CMSTAT, sc->sc_intmask);
416 PUTREG(CMCMD, CM_CONF(CONF_LONG));
419 printf("%s%d: reset: chip configured, status=0x%02x\n",
420 ifp->if_name, ifp->if_unit, GETREG(CMSTAT));
422 PUTREG(CMCMD, CM_CLR(CLR_POR|CLR_RECONFIG));
425 printf("%s%d: reset: bits cleared, status=0x%02x\n",
426 ifp->if_name, ifp->if_unit, GETREG(CMSTAT));
429 sc->sc_reconcount_excessive = ARC_EXCESSIVE_RECONS;
433 sc->sc_intmask |= CM_RI;
434 sc->sc_rx_fillcount = 0;
437 PUTREG(CMCMD, CM_RXBC(2));
438 PUTREG(CMSTAT, sc->sc_intmask);
441 printf("%s%d: reset: started receiver, status=0x%02x\n",
442 ifp->if_name, ifp->if_unit, GETREG(CMSTAT));
445 /* and init transmitter status */
447 sc->sc_tx_fillcount = 0;
449 ifp->if_flags |= IFF_RUNNING;
450 ifp->if_flags &= ~IFF_OACTIVE;
456 * Take interface offline
462 /* Stop the interrupts */
465 /* Stop the interface */
468 /* Stop watchdog timer */
469 sc->sc_arccom.ac_if.if_timer = 0;
473 * Start output on interface. Get another datagram to send
474 * off the interface queue, and copy it to the
475 * interface becore starting the output
477 * this assumes that it is called inside a critical section...
478 * XXX hm... does it still?
485 struct cm_softc *sc = ifp->if_softc;
489 int len, tlen, offset, s, buffer;
491 u_long copystart, lencopy, perbyte;
494 #if defined(CM_DEBUG) && (CM_DEBUG > 3)
495 printf("%s%d: start(%p)\n", ifp->if_name, ifp->if_unit, ifp);
498 if ((ifp->if_flags & IFF_RUNNING) == 0)
503 if (sc->sc_tx_fillcount >= 2) {
508 m = arc_frag_next(ifp);
509 buffer = sc->sc_tx_act ^ 1;
517 * If bpf is listening on this interface, let it
518 * see the packet before we commit it to the wire
520 * (can't give the copy in A2060 card RAM to bpf, because
521 * that RAM is just accessed as on every other byte)
527 if (m->m_len < ARC_HDRLEN)
528 m = m_pullup(m, ARC_HDRLEN);/* gcc does structure padding */
529 printf("%s%d: start: filling %d from %d to %d type %d\n",
530 ifp->if_name, ifp->if_unit, buffer, mtod(m, u_char *)[0],
531 mtod(m, u_char *)[1], mtod(m, u_char *)[2]);
536 cm_ram_ptr = buffer*512;
541 /* write the addresses to RAM and throw them away */
544 * Hardware does this: Yet Another Microsecond Saved.
545 * (btw, timing code says usually 2 microseconds)
546 * PUTMEM(cm_ram_ptr + 0, mtod(m, u_char *)[0]);
549 PUTMEM(cm_ram_ptr + 1, mtod(m, u_char *)[1]);
552 /* get total length left at this point */
553 tlen = m->m_pkthdr.len;
554 if (tlen < ARC_MIN_FORBID_LEN) {
556 PUTMEM(cm_ram_ptr + 2, offset);
558 PUTMEM(cm_ram_ptr + 2, 0);
559 if (tlen <= ARC_MAX_FORBID_LEN)
560 offset = 255; /* !!! */
562 if (tlen > ARC_MAX_LEN)
566 PUTMEM(cm_ram_ptr + 3, offset);
569 cm_ram_ptr += offset;
571 /* lets loop through the mbuf chain */
573 for (mp = m; mp; mp = mp->m_next) {
574 if ((len = mp->m_len)) { /* YAMS */
575 bus_space_write_region_1(
576 rman_get_bustag(sc->mem_res),
577 rman_get_bushandle(sc->mem_res),
578 cm_ram_ptr, mtod(mp, caddr_t), len);
584 sc->sc_broadcast[buffer] = (m->m_flags & M_BCAST) != 0;
585 sc->sc_retransmits[buffer] = (m->m_flags & M_BCAST) ? 1 : 5;
587 /* actually transmit the packet */
590 if (++sc->sc_tx_fillcount > 1) {
592 * We are filled up to the rim. No more bufs for the moment,
595 ifp->if_flags |= IFF_OACTIVE;
598 printf("%s%d: start: starting transmitter on buffer %d\n",
599 ifp->if_name, ifp->if_unit, buffer);
601 /* Transmitter was off, start it */
602 sc->sc_tx_act = buffer;
605 * We still can accept another buf, so don't:
606 * ifp->if_flags |= IFF_OACTIVE;
608 sc->sc_intmask |= CM_TA;
609 PUTREG(CMCMD, CM_TX(buffer));
610 PUTREG(CMSTAT, sc->sc_intmask);
612 sc->sc_arccom.ac_if.if_timer = ARCTIMEOUT;
618 * After 10 times reading the docs, I realized
619 * that in the case the receiver NAKs the buffer request,
620 * the hardware retries till shutdown.
621 * This is integrated now in the code above.
628 * Arcnet interface receiver soft interrupt:
629 * get the stuff out of any filled buffer we find.
635 struct cm_softc *sc = (struct cm_softc *)vsc;
636 int buffer, len, offset, s, type;
639 struct arc_header *ah;
642 ifp = &sc->sc_arccom.ac_if;
645 buffer = sc->sc_rx_act ^ 1;
648 /* Allocate header mbuf */
649 MGETHDR(m, M_DONTWAIT, MT_DATA);
653 * in case s.th. goes wrong with mem, drop it
654 * to make sure the receiver can be started again
655 * count it as input error (we dont have any other
662 m->m_pkthdr.rcvif = ifp;
665 * Align so that IP packet will be longword aligned. Here we
666 * assume that m_data of new packet is longword aligned.
667 * When implementing PHDS, we might have to change it to 2,
668 * (2*sizeof(ulong) - CM_HDRNEWLEN)), packet type dependent.
671 cm_ram_ptr = buffer*512;
672 offset = GETMEM(cm_ram_ptr + 2);
676 offset = GETMEM(cm_ram_ptr + 3);
681 * first +2 bytes for align fixup below
682 * second +2 bytes are for src/dst addresses
684 if ((len + 2 + 2) > MHLEN) {
685 /* attach an mbuf cluster */
686 MCLGET(m, M_DONTWAIT);
688 /* Insist on getting a cluster */
689 if ((m->m_flags & M_EXT) == 0) {
700 type = GETMEM(cm_ram_ptr + offset);
701 m->m_data += 1 + arc_isphds(type);
702 /* mbuf filled with ARCnet addresses */
703 m->m_pkthdr.len = m->m_len = len + 2;
705 ah = mtod(m, struct arc_header *);
706 ah->arc_shost = GETMEM(cm_ram_ptr + 0);
707 ah->arc_dhost = GETMEM(cm_ram_ptr + 1);
709 bus_space_read_region_1(
710 rman_get_bustag(sc->mem_res), rman_get_bushandle(sc->mem_res),
711 cm_ram_ptr + offset, mtod(m, u_char *) + 2, len);
723 /* mark buffer as invalid by source id 0 */
724 PUTMEM(buffer << 9, 0);
727 if (--sc->sc_rx_fillcount == 2 - 1) {
729 /* was off, restart it on buffer just emptied */
730 sc->sc_rx_act = buffer;
731 sc->sc_intmask |= CM_RI;
733 /* this also clears the RI flag interupt: */
734 PUTREG(CMCMD, CM_RXBC(buffer));
735 PUTREG(CMSTAT, sc->sc_intmask);
738 printf("%s%d: srint: restarted rx on buf %d\n",
739 ifp->if_name, ifp->if_unit, buffer);
757 ifp = &(sc->sc_arccom.ac_if);
758 buffer = sc->sc_tx_act;
762 * Normal situtations first for fast path:
763 * If acknowledgement received ok or broadcast, we're ok.
767 if (isr & CM_TMA || sc->sc_broadcast[buffer])
768 sc->sc_arccom.ac_if.if_opackets++;
770 else if (ifp->if_flags & IFF_LINK2 && ifp->if_timer > 0
771 && --sc->sc_retransmits[buffer] > 0) {
772 /* retransmit same buffer */
773 PUTREG(CMCMD, CM_TX(buffer));
781 /* We know we can accept another buffer at this point. */
782 ifp->if_flags &= ~IFF_OACTIVE;
784 if (--sc->sc_tx_fillcount > 0) {
787 * start tx on other buffer.
788 * This also clears the int flag
791 sc->sc_tx_act = buffer;
795 * sc->sc_intmask |= CM_TA;
796 * PUTREG(CMSTAT, sc->sc_intmask);
798 PUTREG(CMCMD, CM_TX(buffer));
799 /* init watchdog timer */
800 ifp->if_timer = ARCTIMEOUT;
802 #if defined(CM_DEBUG) && (CM_DEBUG > 1)
803 printf("%s%d: tint: starting tx on buffer %d, status 0x%02x\n",
804 ifp->if_name, ifp->if_unit, buffer, GETREG(CMSTAT));
807 /* have to disable TX interrupt */
808 sc->sc_intmask &= ~CM_TA;
809 PUTREG(CMSTAT, sc->sc_intmask);
810 /* ... and watchdog timer */
814 printf("%s%d: tint: no more buffers to send, status 0x%02x\n",
815 ifp->if_name, ifp->if_unit, GETREG(CMSTAT));
821 /* schedule soft int to fill a new buffer for us */
822 softintr_schedule(sc->sc_txcookie);
824 /* call it directly */
830 * Our interrupt routine
836 struct cm_softc *sc = arg;
837 struct ifnet *ifp = &sc->sc_arccom.ac_if;
839 u_char isr, maskedisr;
843 isr = GETREG(CMSTAT);
844 maskedisr = isr & sc->sc_intmask;
849 #if defined(CM_DEBUG) && (CM_DEBUG>1)
850 printf("%s%d: intr: status 0x%02x, intmask 0x%02x\n",
851 ifp->if_name, ifp->if_unit, isr, sc->sc_intmask);
854 if (maskedisr & CM_POR) {
856 * XXX We should never see this. Don't bother to store
858 * sc->sc_arccom.ac_anaddr = GETMEM(CMMACOFF);
860 PUTREG(CMCMD, CM_CLR(CLR_POR));
862 "%s%d: intr: got spurious power on reset int\n",
863 ifp->if_name, ifp->if_unit);
866 if (maskedisr & CM_RECON) {
869 * PUTREG(CMCMD, CM_CONF(CONF_LONG));
871 PUTREG(CMCMD, CM_CLR(CLR_RECONFIG));
872 sc->sc_arccom.ac_if.if_collisions++;
875 * If less than 2 seconds per reconfig:
876 * If ARC_EXCESSIVE_RECONFIGS
877 * since last burst, complain and set treshold for
878 * warnings to ARC_EXCESSIVE_RECONS_REWARN.
880 * This allows for, e.g., new stations on the cable, or
881 * cable switching as long as it is over after
882 * (normally) 16 seconds.
884 * XXX TODO: check timeout bits in status word and
885 * double time if necessary.
888 callout_stop(&sc->sc_recon_ch);
889 newsec = time_second;
890 if ((newsec - sc->sc_recontime <= 2) &&
891 (++sc->sc_reconcount == ARC_EXCESSIVE_RECONS)) {
893 "%s%d: excessive token losses, "
895 ifp->if_name, ifp->if_unit);
897 sc->sc_recontime = newsec;
898 callout_reset(&sc->sc_recon_ch, 15 * hz,
899 cm_reconwatch, (void *)sc);
902 if (maskedisr & CM_RI) {
903 #if defined(CM_DEBUG) && (CM_DEBUG > 1)
904 printf("%s%d: intr: hard rint, act %d\n",
905 ifp->if_name, ifp->if_unit, sc->sc_rx_act);
908 buffer = sc->sc_rx_act;
909 /* look if buffer is marked invalid: */
910 if (GETMEM(buffer*512) == 0) {
912 * invalid marked buffer (or illegally
916 "%s%d: spurious RX interupt or sender 0 "
917 " (ignored)\n", ifp->if_name, ifp->if_unit);
919 * restart receiver on same buffer.
920 * XXX maybe better reset interface?
922 PUTREG(CMCMD, CM_RXBC(buffer));
924 if (++sc->sc_rx_fillcount > 1) {
925 sc->sc_intmask &= ~CM_RI;
926 PUTREG(CMSTAT, sc->sc_intmask);
929 sc->sc_rx_act = buffer;
932 * Start receiver on other receive
933 * buffer. This also clears the RI
936 PUTREG(CMCMD, CM_RXBC(buffer));
937 /* in RX intr, so mask is ok for RX */
940 printf("%s%d: strt rx for buf %d, "
942 ifp->if_name, ifp->if_unit,
943 sc->sc_rx_act, GETREG(CMSTAT));
949 * this one starts a soft int to copy out
952 softintr_schedule(sc->sc_rxcookie);
954 /* this one does the copy here */
959 if (maskedisr & CM_TA) {
962 isr = GETREG(CMSTAT);
963 maskedisr = isr & sc->sc_intmask;
965 #if defined(CM_DEBUG) && (CM_DEBUG>1)
966 printf("%s%d: intr (exit): status 0x%02x, intmask 0x%02x\n",
967 ifp->if_name, ifp->if_unit, isr, sc->sc_intmask);
975 struct cm_softc *sc = arg;
976 struct ifnet *ifp = &sc->sc_arccom.ac_if;
978 if (sc->sc_reconcount >= ARC_EXCESSIVE_RECONS) {
979 sc->sc_reconcount = 0;
980 log(LOG_WARNING, "%s%d: token valid again.\n",
981 ifp->if_name, ifp->if_unit);
983 sc->sc_reconcount = 0;
988 * Process an ioctl request.
989 * This code needs some work - it looks pretty ugly.
992 cm_ioctl(ifp, command, data)
1004 ifa = (struct ifaddr *)data;
1005 ifr = (struct ifreq *)data;
1008 #if defined(CM_DEBUG) && (CM_DEBUG > 2)
1009 printf("%s%d: ioctl() called, cmd = 0x%lx\n",
1010 ifp->if_name, ifp->if_unit, command);
1018 error = arc_ioctl(ifp, command, data);
1022 if ((ifp->if_flags & IFF_UP) == 0 &&
1023 (ifp->if_flags & IFF_RUNNING) != 0) {
1025 * If interface is marked down and it is running,
1029 ifp->if_flags &= ~IFF_RUNNING;
1030 } else if ((ifp->if_flags & IFF_UP) != 0 &&
1031 (ifp->if_flags & IFF_RUNNING) == 0) {
1033 * If interface is marked up and it is stopped, then
1050 * watchdog routine for transmitter.
1052 * We need this, because else a receiver whose hardware is alive, but whose
1053 * software has not enabled the Receiver, would make our hardware wait forever
1054 * Discovered this after 20 times reading the docs.
1056 * Only thing we do is disable transmitter. We'll get an transmit timeout,
1057 * and the int handler will have to decide not to retransmit (in case
1058 * retransmission is implemented).
1060 * This one assumes being called inside splimp()
1067 struct cm_softc *sc = ifp->if_softc;
1069 PUTREG(CMCMD, CM_TXDIS);