2 * SPDX-License-Identifier: BSD-4-Clause
4 * Copyright (c) 1994 Herb Peyerl <hpeyerl@novatel.ca>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by Herb Peyerl.
18 * 4. The name of Herb Peyerl may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
37 * Modified from the FreeBSD 1.1.5.1 version by:
39 * INRIA - Sophia Antipolis, France
40 * avega@sophia.inria.fr
44 * Promiscuous mode added and interrupt logic slightly changed
45 * to reduce the number of adapter failures. Transceiver select
46 * logic changed to use value from EEPROM. Autoconfiguration
50 * Chelindbank (Chelyabinsk, Russia)
51 * babkin@hq.icb.chel.su
55 * Pccard support for 3C589 by:
61 * MAINTAINER: Matthew N. Dodd <winter@jurai.net>
65 #include <sys/param.h>
66 #include <sys/systm.h>
67 #include <sys/kernel.h>
68 #include <sys/malloc.h>
70 #include <sys/socket.h>
71 #include <sys/sockio.h>
74 #include <machine/bus.h>
75 #include <machine/resource.h>
79 #include <net/if_var.h>
80 #include <net/if_dl.h>
81 #include <net/if_media.h>
82 #include <net/if_types.h>
83 #include <net/ethernet.h>
86 #include <dev/ep/if_epreg.h>
87 #include <dev/ep/if_epvar.h>
89 /* Exported variables */
90 devclass_t ep_devclass;
92 static int ep_media2if_media[] =
93 {IFM_10_T, IFM_10_5, IFM_NONE, IFM_10_2, IFM_NONE};
96 static void epinit(void *);
97 static int epioctl(struct ifnet *, u_long, caddr_t);
98 static void epstart(struct ifnet *);
100 static void ep_intr_locked(struct ep_softc *);
101 static void epstart_locked(struct ifnet *);
102 static void epinit_locked(struct ep_softc *);
103 static void eptick(void *);
104 static void epwatchdog(struct ep_softc *);
106 /* if_media functions */
107 static int ep_ifmedia_upd(struct ifnet *);
108 static void ep_ifmedia_sts(struct ifnet *, struct ifmediareq *);
110 static void epstop(struct ep_softc *);
111 static void epread(struct ep_softc *);
112 static int eeprom_rdy(struct ep_softc *);
114 #define EP_FTST(sc, f) (sc->stat & (f))
115 #define EP_FSET(sc, f) (sc->stat |= (f))
116 #define EP_FRST(sc, f) (sc->stat &= ~(f))
119 eeprom_rdy(struct ep_softc *sc)
123 for (i = 0; is_eeprom_busy(sc) && i < MAX_EEPROMBUSY; i++)
126 if (i >= MAX_EEPROMBUSY) {
127 device_printf(sc->dev, "eeprom failed to come ready.\n");
135 * get_e: gets a 16 bits word from the EEPROM. we must have set the window
139 ep_get_e(struct ep_softc *sc, uint16_t offset, uint16_t *result)
145 CSR_WRITE_2(sc, EP_W0_EEPROM_COMMAND,
146 (EEPROM_CMD_RD << sc->epb.cmd_off) | offset);
151 (*result) = CSR_READ_2(sc, EP_W0_EEPROM_DATA);
157 ep_get_macaddr(struct ep_softc *sc, u_char *addr)
164 macaddr = (uint16_t *) addr;
167 for (i = EEPROM_NODE_ADDR_0; i <= EEPROM_NODE_ADDR_2; i++) {
168 error = ep_get_e(sc, i, &result);
171 macaddr[i] = htons(result);
177 ep_alloc(device_t dev)
179 struct ep_softc *sc = device_get_softc(dev);
185 sc->iobase = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid,
188 device_printf(dev, "No I/O space?!\n");
193 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE);
195 device_printf(dev, "No irq?!\n");
200 sc->stat = 0; /* 16 bit access */
202 sc->bst = rman_get_bustag(sc->iobase);
203 sc->bsh = rman_get_bushandle(sc->iobase);
205 sc->ep_connectors = 0;
206 sc->ep_connector = 0;
210 error = ep_get_e(sc, EEPROM_PROD_ID, &result);
213 sc->epb.prod_id = result;
215 error = ep_get_e(sc, EEPROM_RESOURCE_CFG, &result);
218 sc->epb.res_cfg = result;
227 ep_get_media(struct ep_softc *sc)
232 config = CSR_READ_2(sc, EP_W0_CONFIG_CTRL);
234 sc->ep_connectors |= AUI;
236 sc->ep_connectors |= BNC;
238 sc->ep_connectors |= UTP;
240 if (!(sc->ep_connectors & 7))
242 device_printf(sc->dev, "no connectors!\n");
245 * This works for most of the cards so we'll do it here.
246 * The cards that require something different can override
249 sc->ep_connector = CSR_READ_2(sc, EP_W0_ADDRESS_CFG) >> ACF_CONNECTOR_BITS;
253 ep_free(device_t dev)
255 struct ep_softc *sc = device_get_softc(dev);
258 bus_teardown_intr(dev, sc->irq, sc->ep_intrhand);
260 bus_release_resource(dev, SYS_RES_IOPORT, 0, sc->iobase);
262 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
269 ep_setup_station(struct ep_softc *sc, u_char *enaddr)
274 * Setup the station address
277 for (i = 0; i < ETHER_ADDR_LEN; i++)
278 CSR_WRITE_1(sc, EP_W2_ADDR_0 + i, enaddr[i]);
282 ep_attach(struct ep_softc *sc)
284 struct ifnet *ifp = NULL;
285 struct ifmedia *ifm = NULL;
290 if (! (sc->stat & F_ENADDR_SKIP)) {
291 error = ep_get_macaddr(sc, sc->eaddr);
293 device_printf(sc->dev, "Unable to get MAC address!\n");
298 ep_setup_station(sc, sc->eaddr);
299 ifp = sc->ifp = if_alloc(IFT_ETHER);
301 device_printf(sc->dev, "if_alloc() failed\n");
307 if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
308 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
309 ifp->if_start = epstart;
310 ifp->if_ioctl = epioctl;
311 ifp->if_init = epinit;
312 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
313 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
314 IFQ_SET_READY(&ifp->if_snd);
316 callout_init_mtx(&sc->watchdog_timer, &sc->sc_mtx, 0);
317 if (!sc->epb.mii_trans) {
318 ifmedia_init(&sc->ifmedia, 0, ep_ifmedia_upd, ep_ifmedia_sts);
320 if (sc->ep_connectors & AUI)
321 ifmedia_add(&sc->ifmedia,
322 IFM_ETHER | IFM_10_5, 0, NULL);
323 if (sc->ep_connectors & UTP)
324 ifmedia_add(&sc->ifmedia,
325 IFM_ETHER | IFM_10_T, 0, NULL);
326 if (sc->ep_connectors & BNC)
327 ifmedia_add(&sc->ifmedia,
328 IFM_ETHER | IFM_10_2, 0, NULL);
329 if (!sc->ep_connectors)
330 ifmedia_add(&sc->ifmedia,
331 IFM_ETHER | IFM_NONE, 0, NULL);
333 ifmedia_set(&sc->ifmedia,
334 IFM_ETHER | ep_media2if_media[sc->ep_connector]);
337 ifm->ifm_media = ifm->ifm_cur->ifm_media;
340 ether_ifattach(ifp, sc->eaddr);
342 #ifdef EP_LOCAL_STATS
343 sc->rx_no_first = sc->rx_no_mbuf = sc->rx_bpf_disc =
344 sc->rx_overrunf = sc->rx_overrunl = sc->tx_underrun = 0;
346 EP_FSET(sc, F_RX_FIRST);
347 sc->top = sc->mcur = 0;
357 ep_detach(device_t dev)
362 sc = device_get_softc(dev);
364 EP_ASSERT_UNLOCKED(sc);
366 if (bus_child_present(dev))
369 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
372 callout_drain(&sc->watchdog_timer);
384 struct ep_softc *sc = xsc;
391 * The order in here seems important. Otherwise we may not receive
395 epinit_locked(struct ep_softc *sc)
397 struct ifnet *ifp = sc->ifp;
403 EP_ASSERT_LOCKED(sc);
407 CSR_WRITE_2(sc, EP_COMMAND, STOP_TRANSCEIVER);
409 CSR_WRITE_2(sc, EP_W4_MEDIA_TYPE, DISABLE_UTP);
412 /* Disable the card */
413 CSR_WRITE_2(sc, EP_W0_CONFIG_CTRL, 0);
415 /* Enable the card */
416 CSR_WRITE_2(sc, EP_W0_CONFIG_CTRL, ENABLE_DRQ_IRQ);
419 /* Reload the ether_addr. */
420 ep_setup_station(sc, IF_LLADDR(sc->ifp));
422 CSR_WRITE_2(sc, EP_COMMAND, RX_RESET);
423 CSR_WRITE_2(sc, EP_COMMAND, TX_RESET);
426 /* Window 1 is operating window */
428 for (i = 0; i < 31; i++)
429 CSR_READ_1(sc, EP_W1_TX_STATUS);
431 /* get rid of stray intr's */
432 CSR_WRITE_2(sc, EP_COMMAND, ACK_INTR | 0xff);
434 CSR_WRITE_2(sc, EP_COMMAND, SET_RD_0_MASK | S_5_INTS);
435 CSR_WRITE_2(sc, EP_COMMAND, SET_INTR_MASK | S_5_INTS);
437 if (ifp->if_flags & IFF_PROMISC)
438 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_FILTER | FIL_INDIVIDUAL |
439 FIL_MULTICAST | FIL_BRDCST | FIL_PROMISC);
441 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_FILTER | FIL_INDIVIDUAL |
442 FIL_MULTICAST | FIL_BRDCST);
444 if (!sc->epb.mii_trans)
447 if (sc->stat & F_HAS_TX_PLL)
448 CSR_WRITE_2(sc, EP_COMMAND, TX_PLL_ENABLE);
449 CSR_WRITE_2(sc, EP_COMMAND, RX_ENABLE);
450 CSR_WRITE_2(sc, EP_COMMAND, TX_ENABLE);
452 ifp->if_drv_flags |= IFF_DRV_RUNNING;
453 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; /* just in case */
455 #ifdef EP_LOCAL_STATS
456 sc->rx_no_first = sc->rx_no_mbuf =
457 sc->rx_overrunf = sc->rx_overrunl = sc->tx_underrun = 0;
459 EP_FSET(sc, F_RX_FIRST);
462 sc->top = sc->mcur = 0;
464 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH);
465 CSR_WRITE_2(sc, EP_COMMAND, SET_TX_START_THRESH | 16);
469 callout_reset(&sc->watchdog_timer, hz, eptick, sc);
473 epstart(struct ifnet *ifp)
483 epstart_locked(struct ifnet *ifp)
493 EP_ASSERT_LOCKED(sc);
495 if (ifp->if_drv_flags & IFF_DRV_OACTIVE)
499 /* Sneak a peek at the next packet */
500 IFQ_DRV_DEQUEUE(&ifp->if_snd, m0);
503 if (!started && (sc->stat & F_HAS_TX_PLL))
504 CSR_WRITE_2(sc, EP_COMMAND, TX_PLL_ENABLE);
506 for (len = 0, m = m0; m != NULL; m = m->m_next)
512 * The 3c509 automatically pads short packets to minimum
513 * ethernet length, but we drop packets that are too large.
514 * Perhaps we should truncate them instead?
516 if (len + pad > ETHER_MAX_LEN) {
517 /* packet is obviously too large: toss it */
518 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
522 if (CSR_READ_2(sc, EP_W1_FREE_TX) < len + pad + 4) {
523 /* no room in FIFO */
524 CSR_WRITE_2(sc, EP_COMMAND, SET_TX_AVAIL_THRESH | (len + pad + 4));
526 if (CSR_READ_2(sc, EP_W1_FREE_TX) < len + pad + 4) {
527 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
528 IFQ_DRV_PREPEND(&ifp->if_snd, m0);
532 CSR_WRITE_2(sc, EP_COMMAND,
533 SET_TX_AVAIL_THRESH | EP_THRESH_DISABLE);
535 CSR_WRITE_2(sc, EP_W1_TX_PIO_WR_1, len);
536 /* Second dword meaningless */
537 CSR_WRITE_2(sc, EP_W1_TX_PIO_WR_1, 0x0);
539 for (m = m0; m != NULL; m = m->m_next) {
541 CSR_WRITE_MULTI_2(sc, EP_W1_TX_PIO_WR_1,
542 mtod(m, uint16_t *), m->m_len / 2);
544 CSR_WRITE_1(sc, EP_W1_TX_PIO_WR_1,
545 *(mtod(m, uint8_t *)+m->m_len - 1));
549 CSR_WRITE_1(sc, EP_W1_TX_PIO_WR_1, 0); /* Padding */
551 /* XXX and drop splhigh here */
556 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
560 * Is another packet coming in? We don't want to overflow
564 if (CSR_READ_2(sc, EP_W1_RX_STATUS) & RX_BYTES_MASK) {
566 * we check if we have packets left, in that case
567 * we prepare to come back later
569 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
570 CSR_WRITE_2(sc, EP_COMMAND, SET_TX_AVAIL_THRESH | 8);
583 sc = (struct ep_softc *) arg;
590 ep_intr_locked(struct ep_softc *sc)
595 /* XXX 4.x splbio'd here to reduce interruptability */
598 * quick fix: Try to detect an interrupt when the card goes away.
600 if (sc->gone || CSR_READ_2(sc, EP_STATUS) == 0xffff)
604 CSR_WRITE_2(sc, EP_COMMAND, SET_INTR_MASK); /* disable all Ints */
608 while ((status = CSR_READ_2(sc, EP_STATUS)) & S_5_INTS) {
610 /* first acknowledge all interrupt sources */
611 CSR_WRITE_2(sc, EP_COMMAND, ACK_INTR | (status & S_MASK));
613 if (status & (S_RX_COMPLETE | S_RX_EARLY))
615 if (status & S_TX_AVAIL) {
618 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
620 CSR_READ_2(sc, EP_W1_FREE_TX);
623 if (status & S_CARD_FAILURE) {
625 #ifdef EP_LOCAL_STATS
626 device_printf(sc->dev, "\n\tStatus: %x\n", status);
628 printf("\tFIFO Diagnostic: %x\n",
629 CSR_READ_2(sc, EP_W4_FIFO_DIAG));
630 printf("\tStat: %x\n", sc->stat);
631 printf("\tIpackets=%d, Opackets=%d\n",
632 ifp->if_get_counter(ifp, IFCOUNTER_IPACKETS),
633 ifp->if_get_counter(ifp, IFCOUNTER_OPACKETS));
634 printf("\tNOF=%d, NOMB=%d, RXOF=%d, RXOL=%d, TXU=%d\n",
635 sc->rx_no_first, sc->rx_no_mbuf, sc->rx_overrunf,
636 sc->rx_overrunl, sc->tx_underrun);
640 device_printf(sc->dev,
641 "Status: %x (input buffer overflow)\n", status);
643 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
650 if (status & S_TX_COMPLETE) {
653 * We need ACK. We do it at the end.
655 * We need to read TX_STATUS until we get a
656 * 0 status in order to turn off the interrupt flag.
658 while ((status = CSR_READ_1(sc, EP_W1_TX_STATUS)) &
660 if (status & TXS_SUCCES_INTR_REQ)
663 (TXS_UNDERRUN | TXS_JABBER |
664 TXS_MAX_COLLISION)) {
665 CSR_WRITE_2(sc, EP_COMMAND, TX_RESET);
666 if (status & TXS_UNDERRUN) {
667 #ifdef EP_LOCAL_STATS
671 if (status & TXS_MAX_COLLISION) {
673 * TXS_MAX_COLLISION we
676 if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 1);
678 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
679 CSR_WRITE_2(sc, EP_COMMAND, TX_ENABLE);
681 * To have a tx_avail_int but giving
682 * the chance to the Reception
684 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
685 CSR_WRITE_2(sc, EP_COMMAND,
686 SET_TX_AVAIL_THRESH | 8);
688 /* pops up the next status */
689 CSR_WRITE_1(sc, EP_W1_TX_STATUS, 0x0);
691 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
693 CSR_READ_2(sc, EP_W1_FREE_TX);
695 } /* end TX_COMPLETE */
698 CSR_WRITE_2(sc, EP_COMMAND, C_INTR_LATCH); /* ACK int Latch */
700 if ((status = CSR_READ_2(sc, EP_STATUS)) & S_5_INTS)
704 CSR_WRITE_2(sc, EP_COMMAND, SET_INTR_MASK | S_5_INTS);
708 epread(struct ep_softc *sc)
710 struct mbuf *top, *mcur, *m;
713 short rx_fifo2, status;
716 /* XXX Must be called with sc locked */
719 status = CSR_READ_2(sc, EP_W1_RX_STATUS);
723 if (status & ERR_RX) {
724 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
725 if (status & ERR_RX_OVERRUN) {
727 * We can think the rx latency is actually
728 * greather than we expect
730 #ifdef EP_LOCAL_STATS
731 if (EP_FTST(sc, F_RX_FIRST))
739 rx_fifo = rx_fifo2 = status & RX_BYTES_MASK;
741 if (EP_FTST(sc, F_RX_FIRST)) {
742 MGETHDR(m, M_NOWAIT, MT_DATA);
745 if (rx_fifo >= MINCLSIZE)
747 sc->top = sc->mcur = top = m;
748 #define EROUND ((sizeof(struct ether_header) + 3) & ~3)
749 #define EOFF (EROUND - sizeof(struct ether_header))
752 /* Read what should be the header. */
753 CSR_READ_MULTI_2(sc, EP_W1_RX_PIO_RD_1,
754 mtod(top, uint16_t *), sizeof(struct ether_header) / 2);
755 top->m_len = sizeof(struct ether_header);
756 rx_fifo -= sizeof(struct ether_header);
757 sc->cur_len = rx_fifo2;
759 /* come here if we didn't have a complete packet last time */
762 sc->cur_len += rx_fifo2;
765 /* Reads what is left in the RX FIFO */
766 while (rx_fifo > 0) {
767 lenthisone = min(rx_fifo, M_TRAILINGSPACE(m));
768 if (lenthisone == 0) { /* no room in this one */
770 MGET(m, M_NOWAIT, MT_DATA);
773 if (rx_fifo >= MINCLSIZE)
777 lenthisone = min(rx_fifo, M_TRAILINGSPACE(m));
779 CSR_READ_MULTI_2(sc, EP_W1_RX_PIO_RD_1,
780 (uint16_t *)(mtod(m, caddr_t)+m->m_len),
782 m->m_len += lenthisone;
784 *(mtod(m, caddr_t)+m->m_len - 1) =
785 CSR_READ_1(sc, EP_W1_RX_PIO_RD_1);
786 rx_fifo -= lenthisone;
789 if (status & ERR_RX_INCOMPLETE) {
790 /* we haven't received the complete packet */
792 #ifdef EP_LOCAL_STATS
793 /* to know how often we come here */
796 EP_FRST(sc, F_RX_FIRST);
797 status = CSR_READ_2(sc, EP_W1_RX_STATUS);
798 if (!(status & ERR_RX_INCOMPLETE)) {
800 * We see if by now, the packet has completly
805 CSR_WRITE_2(sc, EP_COMMAND,
806 SET_RX_EARLY_THRESH | RX_NEXT_EARLY_THRESH);
809 CSR_WRITE_2(sc, EP_COMMAND, RX_DISCARD_TOP_PACK);
810 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
811 EP_FSET(sc, F_RX_FIRST);
812 top->m_pkthdr.rcvif = sc->ifp;
813 top->m_pkthdr.len = sc->cur_len;
816 * Drop locks before calling if_input() since it may re-enter
817 * ep_start() in the netisr case. This would result in a
818 * lock reversal. Better performance might be obtained by
819 * chaining all packets received, dropping the lock, and then
820 * calling if_input() on each one.
823 (*ifp->if_input) (ifp, top);
827 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH);
831 CSR_WRITE_2(sc, EP_COMMAND, RX_DISCARD_TOP_PACK);
835 #ifdef EP_LOCAL_STATS
839 EP_FSET(sc, F_RX_FIRST);
841 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH);
845 ep_ifmedia_upd(struct ifnet *ifp)
847 struct ep_softc *sc = ifp->if_softc;
851 CSR_WRITE_2(sc, EP_COMMAND, STOP_TRANSCEIVER);
853 CSR_WRITE_2(sc, EP_W4_MEDIA_TYPE, DISABLE_UTP);
856 switch (IFM_SUBTYPE(sc->ifmedia.ifm_media)) {
858 if (sc->ep_connectors & UTP) {
859 i = ACF_CONNECTOR_UTP;
861 CSR_WRITE_2(sc, EP_W4_MEDIA_TYPE, ENABLE_UTP);
865 if (sc->ep_connectors & BNC) {
866 i = ACF_CONNECTOR_BNC;
867 CSR_WRITE_2(sc, EP_COMMAND, START_TRANSCEIVER);
868 DELAY(DELAY_MULTIPLE * 1000);
872 if (sc->ep_connectors & AUI)
873 i = ACF_CONNECTOR_AUI;
876 i = sc->ep_connector;
877 device_printf(sc->dev,
878 "strange connector type in EEPROM: assuming AUI\n");
882 j = CSR_READ_2(sc, EP_W0_ADDRESS_CFG) & 0x3fff;
883 CSR_WRITE_2(sc, EP_W0_ADDRESS_CFG, j | (i << ACF_CONNECTOR_BITS));
889 ep_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
891 struct ep_softc *sc = ifp->if_softc;
894 switch (IFM_SUBTYPE(sc->ifmedia.ifm_media)) {
897 ms = CSR_READ_2(sc, EP_W4_MEDIA_TYPE);
899 ifmr->ifm_status = IFM_AVALID;
901 ifmr->ifm_status |= IFM_ACTIVE;
902 ifmr->ifm_active = IFM_ETHER | IFM_10_T;
904 ifmr->ifm_active = IFM_ETHER | IFM_NONE;
908 ifmr->ifm_active = sc->ifmedia.ifm_media;
914 epioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
916 struct ep_softc *sc = ifp->if_softc;
917 struct ifreq *ifr = (struct ifreq *) data;
923 if (((ifp->if_flags & IFF_UP) == 0) &&
924 (ifp->if_drv_flags & IFF_DRV_RUNNING)) {
927 /* reinitialize card on any parameter change */
934 * The Etherlink III has no programmable multicast
935 * filter. We always initialize the card to be
936 * promiscuous to multicast, since we're always a
937 * member of the ALL-SYSTEMS group, so there's no
938 * need to process SIOC*MULTI requests.
944 if (!sc->epb.mii_trans)
945 error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, cmd);
950 error = ether_ioctl(ifp, cmd, data);
962 if (sc->tx_timer != 0 && --sc->tx_timer == 0)
964 callout_reset(&sc->watchdog_timer, hz, eptick, sc);
968 epwatchdog(struct ep_softc *sc)
975 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
981 epstop(struct ep_softc *sc)
984 EP_ASSERT_LOCKED(sc);
986 CSR_WRITE_2(sc, EP_COMMAND, RX_DISABLE);
987 CSR_WRITE_2(sc, EP_COMMAND, RX_DISCARD_TOP_PACK);
990 CSR_WRITE_2(sc, EP_COMMAND, TX_DISABLE);
991 CSR_WRITE_2(sc, EP_COMMAND, STOP_TRANSCEIVER);
994 CSR_WRITE_2(sc, EP_COMMAND, RX_RESET);
996 CSR_WRITE_2(sc, EP_COMMAND, TX_RESET);
999 CSR_WRITE_2(sc, EP_COMMAND, C_INTR_LATCH);
1000 CSR_WRITE_2(sc, EP_COMMAND, SET_RD_0_MASK);
1001 CSR_WRITE_2(sc, EP_COMMAND, SET_INTR_MASK);
1002 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_FILTER);
1004 sc->ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1005 callout_stop(&sc->watchdog_timer);