root/dev/pcmcia/if_xe.c

DEFINITIONS

1. xe_pcmcia_match
2. xe_pcmcia_attach
3. xe_pcmcia_detach
4. xe_pcmcia_activate
5. xe_pcmcia_funce_enaddr
6. xe_pcmcia_lan_nid_ciscallback
7. xe_pcmcia_interpret_manfid
8. xe_pcmcia_manfid_ciscallback
9. xe_intr
10. xe_get
11. xe_mdi_idle
12. xe_mdi_pulse
13. xe_mdi_probe
14. xe_mdi_pulse_bits
15. xe_mdi_read
16. xe_mdi_write
17. xe_statchg
18. xe_mediachange
19. xe_mediastatus
20. xe_reset
21. xe_watchdog
22. xe_stop
23. xe_init
24. xe_start
25. xe_ether_ioctl
26. xe_ioctl
27. xe_set_address
28. xe_cycle_power
29. xe_full_reset
30. xe_reg_dump

    1 /*      $OpenBSD: if_xe.c,v 1.33 2007/06/06 09:43:44 henning Exp $      */
    3 /*
    4  * Copyright (c) 1999 Niklas Hallqvist, Brandon Creighton, Job de Haas
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   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 Niklas Hallqvist,
   18  *      C Stone and Job de Haas.
   19  * 4. The name of the author may not be used to endorse or promote products
   20  *    derived from this software without specific prior written permission
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   32  */
   34 /*
   35  * A driver for Xircom ethernet PC-cards.
   36  *
   37  * The driver has been inspired by the xirc2ps_cs.c driver found in Linux'
   38  * PCMCIA package written by Werner Koch <werner.koch@guug.de>:
   39  * [xirc2ps_cs.c wk 14.04.97] (1.31 1998/12/09 19:32:55)
   40  * I will note that no code was used verbatim from that driver as it is under
   41  * the much too strong GNU General Public License, it was only used as a
   42  * "specification" of sorts.
   43  * Other inspirations have been if_fxp.c, if_ep_pcmcia.c and elink3.c as
   44  * they were found in OpenBSD 2.4.
   45  */
   47 #include "bpfilter.h"
   49 #include <sys/param.h>
   50 #include <sys/systm.h>
   51 #include <sys/device.h>
   52 #include <sys/ioctl.h>
   53 #include <sys/mbuf.h>
   54 #include <sys/malloc.h>
   55 #include <sys/kernel.h>
   56 #include <sys/socket.h>
   57 #include <sys/syslog.h>
   59 #include <net/if.h>
   60 #include <net/if_dl.h>
   61 #include <net/if_media.h>
   62 #include <net/if_types.h>
   64 #ifdef INET
   65 #include <netinet/in.h>
   66 #include <netinet/in_systm.h>
   67 #include <netinet/in_var.h>
   68 #include <netinet/ip.h>
   69 #include <netinet/if_ether.h>
   70 #endif
   72 #if NBPFILTER > 0
   73 #include <net/bpf.h>
   74 #endif
   76 /*
   77  * Maximum number of bytes to read per interrupt.  Linux recommends
   78  * somewhere between 2000-22000.
   79  * XXX This is currently a hard maximum.
   80  */
   81 #define MAX_BYTES_INTR 12000
   83 #include <dev/mii/miivar.h>
   85 #include <dev/pcmcia/pcmciareg.h>
   86 #include <dev/pcmcia/pcmciavar.h>
   87 #include <dev/pcmcia/pcmciadevs.h>
   88 #include <dev/pcmcia/if_xereg.h>
   90 #ifdef __GNUC__
   91 #define INLINE  __inline
   92 #else
   93 #define INLINE
   94 #endif  /* __GNUC__ */
   96 #ifdef XEDEBUG
   98 #define XED_CONFIG      0x1
   99 #define XED_MII         0x2
  100 #define XED_INTR        0x4
  101 #define XED_FIFO        0x8
  103 #ifndef XEDEBUG_DEF
  104 #define XEDEBUG_DEF     (XED_CONFIG|XED_INTR)
  105 #endif  /* XEDEBUG_DEF */
  107 int xedebug = XEDEBUG_DEF;
  109 #define DPRINTF(cat, x) if (xedebug & (cat)) printf x
  111 #else   /* XEDEBUG */
  112 #define DPRINTF(cat, x) (void)0
  113 #endif  /* XEDEBUG */
  115 int     xe_pcmcia_match(struct device *, void *, void *);
  116 void    xe_pcmcia_attach(struct device *, struct device *, void *);
  117 int     xe_pcmcia_detach(struct device *, int);
  118 int     xe_pcmcia_activate(struct device *, enum devact);
  120 /*
  121  * In case this chipset ever turns up out of pcmcia attachments (very
  122  * unlikely) do the driver splitup.
  123  */
  124 struct xe_softc {
  125         struct  device sc_dev;                  /* Generic device info */
u_int32_t       sc_flags;               /* Misc. flags */
  127         void    *sc_ih;                         /* Interrupt handler */
  128         struct  arpcom sc_arpcom;               /* Ethernet common part */
  129         struct  ifmedia sc_media;               /* Media control */
  130         struct  mii_data sc_mii;                /* MII media information */
  131         int     sc_all_mcasts;                  /* Receive all multicasts */
bus_space_tag_t sc_bst;                 /* Bus cookie */
bus_space_handle_t      sc_bsh;         /* Bus I/O handle */
bus_size_t      sc_offset;              /* Offset of registers */
u_int8_t        sc_rev;                 /* Chip revision */
  136 };
  138 #define XEF_MOHAWK      0x001
  139 #define XEF_DINGO       0x002
  140 #define XEF_MODEM       0x004
  141 #define XEF_UNSUPPORTED 0x008
  142 #define XEF_CE          0x010
  143 #define XEF_CE2         0x020
  144 #define XEF_CE3         0x040
  145 #define XEF_CE33        0x080
  146 #define XEF_CE56        0x100
  148 struct xe_pcmcia_softc {
  149         struct  xe_softc sc_xe;                 /* Generic device info */
  150         struct  pcmcia_mem_handle sc_pcmh;      /* PCMCIA memspace info */
  151         int     sc_mem_window;                  /* mem window */
  152         struct  pcmcia_io_handle sc_pcioh;      /* iospace info */
  153         int     sc_io_window;                   /* io window info */
  154         struct  pcmcia_function *sc_pf;         /* PCMCIA function */
  155 };
  157 /* Autoconfig definition of driver back-end */
  158 struct cfdriver xe_cd = {
NULL, "xe", DV_IFNET
  160 };
  162 struct cfattach xe_pcmcia_ca = {
  163         sizeof (struct xe_pcmcia_softc), xe_pcmcia_match, xe_pcmcia_attach,
xe_pcmcia_detach, xe_pcmcia_activate
  165 };
  167 void    xe_cycle_power(struct xe_softc *);
  168 int     xe_ether_ioctl(struct ifnet *, u_long cmd, caddr_t);
  169 void    xe_full_reset(struct xe_softc *);
  170 void    xe_init(struct xe_softc *);
  171 int     xe_intr(void *);
  172 int     xe_ioctl(struct ifnet *, u_long, caddr_t);
  173 int     xe_mdi_read(struct device *, int, int);
  174 void    xe_mdi_write(struct device *, int, int, int);
  175 int     xe_mediachange(struct ifnet *);
  176 void    xe_mediastatus(struct ifnet *, struct ifmediareq *);
  177 int     xe_pcmcia_funce_enaddr(struct device *, u_int8_t *);
u_int32_t xe_pcmcia_interpret_manfid(struct device *);
  179 int     xe_pcmcia_lan_nid_ciscallback(struct pcmcia_tuple *, void *);
  180 int     xe_pcmcia_manfid_ciscallback(struct pcmcia_tuple *, void *);
u_int16_t xe_get(struct xe_softc *);
  182 void    xe_reset(struct xe_softc *);
  183 void    xe_set_address(struct xe_softc *);
  184 void    xe_start(struct ifnet *);
  185 void    xe_statchg(struct device *);
  186 void    xe_stop(struct xe_softc *);
  187 void    xe_watchdog(struct ifnet *);
  188 #ifdef XEDEBUG
  189 void    xe_reg_dump(struct xe_softc *);
  190 #endif  /* XEDEBUG */
  192 int
xe_pcmcia_match(parent, match, aux)
  194         struct device *parent;
  195         void *match, *aux;
  196 {
  197         struct pcmcia_attach_args *pa = aux;
  199         if (pa->pf->function != PCMCIA_FUNCTION_NETWORK)
  200                 return (0);
  202         switch (pa->manufacturer) {
  203         case PCMCIA_VENDOR_COMPAQ:
  204         case PCMCIA_VENDOR_COMPAQ2:
  205                 return (0);
  207         case PCMCIA_VENDOR_INTEL:
  208         case PCMCIA_VENDOR_XIRCOM:
  209                 /* XXX Per-productid checking here. */
  210                 return (1);
  212         default:
  213                 return (0);
  214         }
  215 }
  217 void
xe_pcmcia_attach(parent, self, aux)
  219         struct device *parent, *self;
  220         void *aux;
  221 {
  222         struct xe_pcmcia_softc *psc = (struct xe_pcmcia_softc *)self;
  223         struct xe_softc *sc = &psc->sc_xe;
  224         struct pcmcia_attach_args *pa = aux;
  225         struct pcmcia_function *pf = pa->pf;
  226         struct pcmcia_config_entry *cfe;
  227         struct ifnet *ifp;
u_int8_t myla[ETHER_ADDR_LEN], *enaddr = NULL;
  229         int state = 0;
  230         struct pcmcia_mem_handle pcmh;
  231         int ccr_window;
bus_size_t ccr_offset;
  233         const char *intrstr;
psc->sc_pf = pf;
  237 #if 0
  238         /* Figure out what card we are. */
sc->sc_flags = xe_pcmcia_interpret_manfid(parent);
  240 #endif
  241         if (sc->sc_flags & XEF_UNSUPPORTED) {
printf(": card unsupported\n");
  243                 goto bad;
  244         }
  246         /* Tell the pcmcia framework where the CCR is. */
pf->ccr_base = 0x800;
pf->ccr_mask = 0x67;
  250         /* Fake a cfe. */
SIMPLEQ_FIRST(&pa->pf->cfe_head) = cfe = (struct pcmcia_config_entry *)
malloc(sizeof *cfe, M_DEVBUF, M_NOWAIT);
  253         if (!cfe) {
printf(": function enable failed\n");
  255                 return;
  256         }
bzero(cfe, sizeof *cfe);
  259         /*
  260          * XXX Use preprocessor symbols instead.
  261          * Enable ethernet & its interrupts, wiring them to -INT
  262          * No I/O base.
  263          */
cfe->number = 0x5;
cfe->flags = 0;         /* XXX Check! */
cfe->iftype = PCMCIA_IFTYPE_IO;
cfe->num_iospace = 0;
cfe->num_memspace = 0;
cfe->irqmask = 0x8eb0;
  271         /* Enable the card. */
pcmcia_function_init(pa->pf, cfe);
  273         if (pcmcia_function_enable(pa->pf)) {
printf(": function enable failed\n");
  275                 goto bad;
  276         }
state++;
  280         if (pcmcia_io_alloc(pa->pf, 0, 16, 16, &psc->sc_pcioh)) {
printf(": io allocation failed\n");
  282                 goto bad;
  283         }
state++;
  287         if (pcmcia_io_map(pa->pf, PCMCIA_WIDTH_IO16, 0, 16, &psc->sc_pcioh,
  288                 &psc->sc_io_window)) {
printf(": can't map io space\n");
  290                 goto bad;
  291         }
sc->sc_bst = psc->sc_pcioh.iot;
sc->sc_bsh = psc->sc_pcioh.ioh;
sc->sc_offset = 0;
printf(" port 0x%lx/%d", psc->sc_pcioh.addr, 16);
  298 #if 0
  299         if (pcmcia_mem_alloc(pf, 16, &psc->sc_pcmh)) {
printf(": pcmcia memory allocation failed\n");
  301                 goto bad;
  302         }
state++;
  305         if (pcmcia_mem_map(pf, PCMCIA_MEM_ATTR, 0x300, 16, &psc->sc_pcmh,
  306             &sc->sc_offset, &psc->sc_mem_window)) {
printf(": pcmcia memory mapping failed\n");
  308                 goto bad;
  309         }
sc->sc_bst = psc->sc_pcmh.memt;
sc->sc_bsh = psc->sc_pcmh.memh;
  313 #endif
  315         /* Figure out what card we are. */
sc->sc_flags = xe_pcmcia_interpret_manfid(parent);
  318         /*
  319          * Configuration as advised by DINGO documentation.
  320          * We only know about this flag after the manfid interpretation.
  321          * Dingo has some extra configuration registers in the CCR space.
  322          */
  323         if (sc->sc_flags & XEF_DINGO) {
  324                 if (pcmcia_mem_alloc(pf, PCMCIA_CCR_SIZE_DINGO, &pcmh)) {
DPRINTF(XED_CONFIG, ("bad mem alloc\n"));
  326                         goto bad;
  327                 }
  329                 if (pcmcia_mem_map(pf, PCMCIA_MEM_ATTR, pf->ccr_base,
PCMCIA_CCR_SIZE_DINGO, &pcmh, &ccr_offset,
  331                     &ccr_window)) {
DPRINTF(XED_CONFIG, ("bad mem map\n"));
pcmcia_mem_free(pf, &pcmh);
  334                         goto bad;
  335                 }
bus_space_write_1(pcmh.memt, pcmh.memh,
ccr_offset + PCMCIA_CCR_DCOR0, PCMCIA_CCR_DCOR0_SFINT);
bus_space_write_1(pcmh.memt, pcmh.memh,
ccr_offset + PCMCIA_CCR_DCOR1,
PCMCIA_CCR_DCOR1_FORCE_LEVIREQ | PCMCIA_CCR_DCOR1_D6);
bus_space_write_1(pcmh.memt, pcmh.memh,
ccr_offset + PCMCIA_CCR_DCOR2, 0);
bus_space_write_1(pcmh.memt, pcmh.memh,
ccr_offset + PCMCIA_CCR_DCOR3, 0);
bus_space_write_1(pcmh.memt, pcmh.memh,
ccr_offset + PCMCIA_CCR_DCOR4, 0);
  349                 /* We don't need them anymore and can free them (I think). */
pcmcia_mem_unmap(pf, ccr_window);
pcmcia_mem_free(pf, &pcmh);
  352         }
  354         /*
  355          * Try to get the ethernet address from FUNCE/LAN_NID tuple.
  356          */
  357         if (xe_pcmcia_funce_enaddr(parent, myla))
enaddr = myla;
ifp = &sc->sc_arpcom.ac_if;
  360         if (enaddr)
bcopy(enaddr, sc->sc_arpcom.ac_enaddr, ETHER_ADDR_LEN);
  362         else {
printf(", unable to get ethernet address\n");
  364                 goto bad;
  365         }
bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
ifp->if_softc = sc;
ifp->if_flags =
IFF_BROADCAST | IFF_NOTRAILERS | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = xe_ioctl;
ifp->if_start = xe_start;
ifp->if_watchdog = xe_watchdog;
IFQ_SET_READY(&ifp->if_snd);
  376         /* Establish the interrupt. */
sc->sc_ih = pcmcia_intr_establish(pa->pf, IPL_NET, xe_intr, sc,
sc->sc_dev.dv_xname);
  379         if (sc->sc_ih == NULL) {
printf(", couldn't establish interrupt\n");
  381                 goto bad;
  382         }
intrstr = pcmcia_intr_string(psc->sc_pf, sc->sc_ih);
printf("%s%s: address %s\n", *intrstr ? ", " : "", intrstr,
ether_sprintf(sc->sc_arpcom.ac_enaddr));
  387         /* Reset and initialize the card. */
xe_full_reset(sc);
  390         /* Initialize our media structures and probe the phy. */
sc->sc_mii.mii_ifp = ifp;
sc->sc_mii.mii_readreg = xe_mdi_read;
sc->sc_mii.mii_writereg = xe_mdi_write;
sc->sc_mii.mii_statchg = xe_statchg;
ifmedia_init(&sc->sc_mii.mii_media, IFM_IMASK, xe_mediachange,
xe_mediastatus);
DPRINTF(XED_MII | XED_CONFIG,
  398             ("bmsr %x\n", xe_mdi_read(&sc->sc_dev, 0, 1)));
mii_attach(self, &sc->sc_mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY,
  400             0);
  401         if (LIST_FIRST(&sc->sc_mii.mii_phys) == NULL)
ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER | IFM_AUTO, 0,
NULL);
ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER | IFM_AUTO);
  406         /*
  407          * Attach the interface.
  408          */
if_attach(ifp);
ether_ifattach(ifp);
  412         /*
  413          * Reset and initialize the card again for DINGO (as found in Linux
  414          * driver).  Without this Dingo will get a watchdog timeout the first
  415          * time.  The ugly media tickling seems to be necessary for getting
  416          * autonegotiation to work too.
  417          */
  418         if (sc->sc_flags & XEF_DINGO) {
xe_full_reset(sc);
xe_init(sc);
ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER | IFM_AUTO);
ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER | IFM_NONE);
xe_stop(sc);
  424         }
  426 #ifdef notyet
pcmcia_function_disable(pa->pf);
  428 #endif  /* notyet */
  430         return;
bad:
  433         if (state > 2)
pcmcia_io_unmap(pf, psc->sc_io_window);
  435         if (state > 1)
pcmcia_io_free(pf, &psc->sc_pcioh);
  437         if (state > 0)
pcmcia_function_disable(pa->pf);
free(cfe, M_DEVBUF);
  440 }
  442 int
xe_pcmcia_detach(dev, flags)
  444         struct device *dev;
  445         int flags;
  446 {
  447         struct xe_pcmcia_softc *psc = (struct xe_pcmcia_softc *)dev;
  448         struct xe_softc *sc = &psc->sc_xe;
  449         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  450         int rv = 0;
mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
pcmcia_io_unmap(psc->sc_pf, psc->sc_io_window);
pcmcia_io_free(psc->sc_pf, &psc->sc_pcioh);
ether_ifdetach(ifp);
if_detach(ifp);
  461         return (rv);
  462 }
  464 int
xe_pcmcia_activate(dev, act)
  466         struct device *dev;
  467         enum devact act;
  468 {
  469         struct xe_pcmcia_softc *sc = (struct xe_pcmcia_softc *)dev;
  470         struct ifnet *ifp = &sc->sc_xe.sc_arpcom.ac_if;
  471         int s;
s = splnet();
  474         switch (act) {
  475         case DVACT_ACTIVATE:
pcmcia_function_enable(sc->sc_pf);
sc->sc_xe.sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET,
xe_intr, sc, sc->sc_xe.sc_dev.dv_xname);
xe_init(&sc->sc_xe);
  480                 break;
  482         case DVACT_DEACTIVATE:
ifp->if_timer = 0;
  484                 if (ifp->if_flags & IFF_RUNNING)
xe_stop(&sc->sc_xe);
pcmcia_intr_disestablish(sc->sc_pf, sc->sc_xe.sc_ih);
pcmcia_function_disable(sc->sc_pf);
  488                 break;
  489         }
splx(s);
  491         return (0);
  492 }
  494 /*
  495  * XXX These two functions might be OK to factor out into pcmcia.c since
  496  * if_sm_pcmcia.c uses similar ones.
  497  */
  498 int
xe_pcmcia_funce_enaddr(parent, myla)
  500         struct device *parent;
u_int8_t *myla;
  502 {
  503         /* XXX The Linux driver has more ways to do this in case of failure. */
  504         return (pcmcia_scan_cis(parent, xe_pcmcia_lan_nid_ciscallback, myla));
  505 }
  507 int
xe_pcmcia_lan_nid_ciscallback(tuple, arg)
  509         struct pcmcia_tuple *tuple;
  510         void *arg;
  511 {
u_int8_t *myla = arg;
  513         int i;
  515         if (tuple->code == PCMCIA_CISTPL_FUNCE) {
  516                 if (tuple->length < 2)
  517                         return (0);
  519                 switch (pcmcia_tuple_read_1(tuple, 0)) {
  520                 case PCMCIA_TPLFE_TYPE_LAN_NID:
  521                         if (pcmcia_tuple_read_1(tuple, 1) != ETHER_ADDR_LEN)
  522                                 return (0);
  523                         break;
  525                 case 0x02:
  526                         /*
  527                          * Not sure about this, I don't have a CE2
  528                          * that puts the ethernet addr here.
  529                          */
  530                         if (pcmcia_tuple_read_1(tuple, 1) != 13)
  531                                 return (0);
  532                         break;
  534                 default:
  535                         return (0);
  536                 }
  538                 for (i = 0; i < ETHER_ADDR_LEN; i++)
myla[i] = pcmcia_tuple_read_1(tuple, i + 2);
  540                 return (1);
  541         }
  543         /* Yet another spot where this might be. */
  544         if (tuple->code == 0x89) {
pcmcia_tuple_read_1(tuple, 1);
  546                 for (i = 0; i < ETHER_ADDR_LEN; i++)
myla[i] = pcmcia_tuple_read_1(tuple, i + 2);
  548                 return (1);
  549         }
  550         return (0);
  551 }
u_int32_t
xe_pcmcia_interpret_manfid (parent)
  555         struct device *parent;
  556 {
u_int32_t flags = 0;
  558         struct pcmcia_softc *psc = (struct pcmcia_softc *)parent;
  559         char *tptr;
  561         if (!pcmcia_scan_cis(parent, xe_pcmcia_manfid_ciscallback, &flags))
  562                 return (XEF_UNSUPPORTED);
  564         if (flags & XEF_CE) {
tptr = memchr(psc->card.cis1_info[2], 'C',
strlen(psc->card.cis1_info[2]));
  567                 /* XXX not sure if other CE2s hide "CE2" in different places */
  568                 if (tptr && *(tptr + 1) == 'E' && *(tptr + 2) == '2') {
flags ^= (XEF_CE | XEF_UNSUPPORTED);
flags |= XEF_CE2;
  571                 }
  572         }
  573         return (flags);
  574 }
  576 int
xe_pcmcia_manfid_ciscallback(tuple, arg)
  578         struct pcmcia_tuple *tuple;
  579         void *arg;
  580 {
u_int32_t *flagsp = arg;
u_int8_t media, product;
  584         if (tuple->code == PCMCIA_CISTPL_MANFID) {
  585                 if (tuple->length < 2)
  586                         return (0);
media = pcmcia_tuple_read_1(tuple, 3);
product = pcmcia_tuple_read_1(tuple, 4);
  591                 if (!(product & XEPROD_CREDITCARD) ||
  592                     !(media & XEMEDIA_ETHER)) {
  593                         *flagsp |= XEF_UNSUPPORTED;
  594                         return (1);
  595                 }
  597                 if (media & XEMEDIA_MODEM)
  598                         *flagsp |= XEF_MODEM;
  600                 switch (product & XEPROD_IDMASK) {
  601                 case 1:
  602                         /* XXX Can be CE2 too (we double-check later). */
  603                         *flagsp |= XEF_CE | XEF_UNSUPPORTED;
  604                         break;
  605                 case 2:
  606                         *flagsp |= XEF_CE2;
  607                         break;
  608                 case 3:
  609                         if (!(*flagsp & XEF_MODEM))
  610                                 *flagsp |= XEF_MOHAWK;
  611                         *flagsp |= XEF_CE3;
  612                         break;
  613                 case 4:
  614                         *flagsp |= XEF_CE33;
  615                         break;
  616                 case 5:
  617                         *flagsp |= XEF_CE56 | XEF_MOHAWK;
  618                         break;
  619                 case 6:
  620                 case 7:
  621                         *flagsp |= XEF_CE56 | XEF_MOHAWK | XEF_DINGO;
  622                         break;
  623                 default:
  624                         *flagsp |= XEF_UNSUPPORTED;
  625                         break;
  626                 }
  628                 return (1);
  629         }
  630         return (0);
  631 }
  633 int
xe_intr(arg)
  635         void *arg;
  636 {
  637         struct xe_softc *sc = arg;
  638         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
u_int8_t esr, rsr, isr, rx_status, savedpage;
u_int16_t tx_status, recvcount = 0, tempint;
ifp->if_timer = 0;      /* turn watchdog timer off */
  644         if (sc->sc_flags & XEF_MOHAWK) {
  645                 /* Disable interrupt (Linux does it). */
bus_space_write_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + CR,
  647                     0);
  648         }
savedpage =
bus_space_read_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + PR);
PAGE(sc, 0);
esr = bus_space_read_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + ESR);
isr = bus_space_read_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + ISR0);
rsr = bus_space_read_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + RSR);
  658         /* Check to see if card has been ejected. */
  659         if (isr == 0xff) {
printf("%s: interrupt for dead card\n", sc->sc_dev.dv_xname);
  661                 goto end;
  662         }
PAGE(sc, 40);
rx_status =
bus_space_read_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + RXST0);
tx_status =
bus_space_read_2(sc->sc_bst, sc->sc_bsh, sc->sc_offset + TXST0);
  670         /*
  671          * XXX Linux writes to RXST0 and TXST* here.  My CE2 works just fine
  672          * without it, and I can't see an obvious reason for it.
  673          */
PAGE(sc, 0);
  676         while (esr & FULL_PKT_RCV) {
  677                 if (!(rsr & RSR_RX_OK))
  678                         break;
  680                 /* Compare bytes read this interrupt to hard maximum. */
  681                 if (recvcount > MAX_BYTES_INTR) {
DPRINTF(XED_INTR,
  683                             ("%s: too many bytes this interrupt\n",
sc->sc_dev.dv_xname));
ifp->if_iqdrops++;
  686                         /* Drop packet. */
bus_space_write_2(sc->sc_bst, sc->sc_bsh,
sc->sc_offset + DO0, DO_SKIP_RX_PKT);
  689                 }
tempint = xe_get(sc);
recvcount += tempint;
ifp->if_ibytes += tempint;
esr = bus_space_read_1(sc->sc_bst, sc->sc_bsh,
sc->sc_offset + ESR);
rsr = bus_space_read_1(sc->sc_bst, sc->sc_bsh,
sc->sc_offset + RSR);
  697         }
  699         /* Packet too long? */
  700         if (rsr & RSR_TOO_LONG) {
ifp->if_ierrors++;
DPRINTF(XED_INTR,
  703                     ("%s: packet too long\n", sc->sc_dev.dv_xname));
  704         }
  706         /* CRC error? */
  707         if (rsr & RSR_CRCERR) {
ifp->if_ierrors++;
DPRINTF(XED_INTR,
  710                     ("%s: CRC error detected\n", sc->sc_dev.dv_xname));
  711         }
  713         /* Alignment error? */
  714         if (rsr & RSR_ALIGNERR) {
ifp->if_ierrors++;
DPRINTF(XED_INTR,
  717                     ("%s: alignment error detected\n", sc->sc_dev.dv_xname));
  718         }
  720         /* Check for rx overrun. */
  721         if (rx_status & RX_OVERRUN) {
bus_space_write_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + CR,
CLR_RX_OVERRUN);
DPRINTF(XED_INTR, ("overrun cleared\n"));
  725         }
  727         /* Try to start more packets transmitting. */
  728         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
xe_start(ifp);
  731         /* Detected excessive collisions? */
  732         if ((tx_status & EXCESSIVE_COLL) && ifp->if_opackets > 0) {
DPRINTF(XED_INTR,
  734                     ("%s: excessive collisions\n", sc->sc_dev.dv_xname));
bus_space_write_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + CR,
RESTART_TX);
ifp->if_oerrors++;
  738         }
  740         if ((tx_status & TX_ABORT) && ifp->if_opackets > 0)
ifp->if_oerrors++;
end:
  744         /* Reenable interrupts. */
PAGE(sc, savedpage);
bus_space_write_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + CR,
ENABLE_INT);
  749         return (1);
  750 }
u_int16_t
xe_get(sc)
  754         struct xe_softc *sc;
  755 {
u_int8_t rsr;
  757         struct mbuf *top, **mp, *m;
  758         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
u_int16_t pktlen, len, recvcount = 0;
u_int8_t *data;
PAGE(sc, 0);
rsr = bus_space_read_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + RSR);
pktlen =
bus_space_read_2(sc->sc_bst, sc->sc_bsh, sc->sc_offset + RBC0) &
RBC_COUNT_MASK;
  768         if (pktlen == 0) {
  769                 /*
  770                  * XXX At least one CE2 sets RBC0 == 0 occasionally, and only
  771                  * when MPE is set.  It is not known why.
  772                  */
  773                 return (0);
  774         }
recvcount += pktlen;
MGETHDR(m, M_DONTWAIT, MT_DATA);
  778         if (m == 0)
  779                 return (recvcount);
m->m_pkthdr.rcvif = ifp;
m->m_pkthdr.len = pktlen;
len = MHLEN;
top = 0;
mp = &top;
  786         while (pktlen > 0) {
  787                 if (top) {
MGET(m, M_DONTWAIT, MT_DATA);
  789                         if (m == 0) {
m_freem(top);
  791                                 return (recvcount);
  792                         }
len = MLEN;
  794                 }
  795                 if (pktlen >= MINCLSIZE) {
MCLGET(m, M_DONTWAIT);
  797                         if (!(m->m_flags & M_EXT)) {
m_freem(m);
m_freem(top);
  800                                 return (recvcount);
  801                         }
len = MCLBYTES;
  803                 }
  804                 if (!top) {
caddr_t newdata = (caddr_t)ALIGN(m->m_data +
  806                             sizeof (struct ether_header)) -
  807                             sizeof (struct ether_header);
len -= newdata - m->m_data;
m->m_data = newdata;
  810                 }
len = min(pktlen, len);
data = mtod(m, u_int8_t *);
  814                 if (len > 1) {
len &= ~1;
bus_space_read_raw_multi_2(sc->sc_bst, sc->sc_bsh,
sc->sc_offset + EDP, data, len);
  818                 } else
  819                         *data = bus_space_read_1(sc->sc_bst, sc->sc_bsh,
sc->sc_offset + EDP);
m->m_len = len;
pktlen -= len;
  823                 *mp = m;
mp = &m->m_next;
  825         }
  827         /* Skip Rx packet. */
bus_space_write_2(sc->sc_bst, sc->sc_bsh, sc->sc_offset + DO0,
DO_SKIP_RX_PKT);
ifp->if_ipackets++;
  833 #if NBPFILTER > 0
  834         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, top, BPF_DIRECTION_IN);
  836 #endif
ether_input_mbuf(ifp, top);
  839         return (recvcount);
  840 }
  843 /*
  844  * Serial management for the MII.
  845  * The DELAY's below stem from the fact that the maximum frequency
  846  * acceptable on the MDC pin is 2.5 MHz and fast processors can easily
  847  * go much faster than that.
  848  */
  850 /* Let the MII serial management be idle for one period. */
  851 static INLINE void xe_mdi_idle(struct xe_softc *);
  852 static INLINE void
xe_mdi_idle(sc)
  854         struct xe_softc *sc;
  855 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_size_t offset = sc->sc_offset;
  860         /* Drive MDC low... */
bus_space_write_1(bst, bsh, offset + GP2, MDC_LOW);
DELAY(1);
  864         /* and high again. */
bus_space_write_1(bst, bsh, offset + GP2, MDC_HIGH);
DELAY(1);
  867 }
  869 /* Pulse out one bit of data. */
  870 static INLINE void xe_mdi_pulse(struct xe_softc *, int);
  871 static INLINE void
xe_mdi_pulse(sc, data)
  873         struct xe_softc *sc;
  874         int data;
  875 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_size_t offset = sc->sc_offset;
u_int8_t bit = data ? MDIO_HIGH : MDIO_LOW;
  881         /* First latch the data bit MDIO with clock bit MDC low...*/
bus_space_write_1(bst, bsh, offset + GP2, bit | MDC_LOW);
DELAY(1);
  885         /* then raise the clock again, preserving the data bit. */
bus_space_write_1(bst, bsh, offset + GP2, bit | MDC_HIGH);
DELAY(1);
  888 }
  890 /* Probe one bit of data. */
  891 static INLINE int xe_mdi_probe(struct xe_softc *sc);
  892 static INLINE int
xe_mdi_probe(sc)
  894         struct xe_softc *sc;
  895 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_size_t offset = sc->sc_offset;
u_int8_t x;
  901         /* Pull clock bit MDCK low... */
bus_space_write_1(bst, bsh, offset + GP2, MDC_LOW);
DELAY(1);
  905         /* Read data and drive clock high again. */
x = bus_space_read_1(bst, bsh, offset + GP2) & MDIO;
bus_space_write_1(bst, bsh, offset + GP2, MDC_HIGH);
DELAY(1);
  910         return (x);
  911 }
  913 /* Pulse out a sequence of data bits. */
  914 static INLINE void xe_mdi_pulse_bits(struct xe_softc *, u_int32_t, int);
  915 static INLINE void
xe_mdi_pulse_bits(sc, data, len)
  917         struct xe_softc *sc;
u_int32_t data;
  919         int len;
  920 {
u_int32_t mask;
  923         for (mask = 1 << (len - 1); mask; mask >>= 1)
xe_mdi_pulse(sc, data & mask);
  925 }
  927 /* Read a PHY register. */
  928 int
xe_mdi_read(self, phy, reg)
  930         struct device *self;
  931         int phy;
  932         int reg;
  933 {
  934         struct xe_softc *sc = (struct xe_softc *)self;
  935         int i;
u_int32_t mask;
u_int32_t data = 0;
PAGE(sc, 2);
  940         for (i = 0; i < 32; i++)        /* Synchronize. */
xe_mdi_pulse(sc, 1);
xe_mdi_pulse_bits(sc, 0x06, 4); /* Start + Read opcode */
xe_mdi_pulse_bits(sc, phy, 5);  /* PHY address */
xe_mdi_pulse_bits(sc, reg, 5);  /* PHY register */
xe_mdi_idle(sc);                /* Turn around. */
xe_mdi_probe(sc);               /* Drop initial zero bit. */
  948         for (mask = 1 << 15; mask; mask >>= 1)
  949                 if (xe_mdi_probe(sc))
data |= mask;
xe_mdi_idle(sc);
DPRINTF(XED_MII,
  954             ("xe_mdi_read: phy %d reg %d -> %x\n", phy, reg, data));
  955         return (data);
  956 }
  958 /* Write a PHY register. */
  959 void
xe_mdi_write(self, phy, reg, value)
  961         struct device *self;
  962         int phy;
  963         int reg;
  964         int value;
  965 {
  966         struct xe_softc *sc = (struct xe_softc *)self;
  967         int i;
PAGE(sc, 2);
  970         for (i = 0; i < 32; i++)        /* Synchronize. */
xe_mdi_pulse(sc, 1);
xe_mdi_pulse_bits(sc, 0x05, 4); /* Start + Write opcode */
xe_mdi_pulse_bits(sc, phy, 5);  /* PHY address */
xe_mdi_pulse_bits(sc, reg, 5);  /* PHY register */
xe_mdi_pulse_bits(sc, 0x02, 2); /* Turn around. */
xe_mdi_pulse_bits(sc, value, 16);       /* Write the data */
xe_mdi_idle(sc);                /* Idle away. */
DPRINTF(XED_MII,
  980             ("xe_mdi_write: phy %d reg %d val %x\n", phy, reg, value));
  981 }
  983 void
xe_statchg(self)
  985         struct device *self;
  986 {
  987         /* XXX Update ifp->if_baudrate */
  988 }
  990 /*
  991  * Change media according to request.
  992  */
  993 int
xe_mediachange(ifp)
  995         struct ifnet *ifp;
  996 {
  997         if (ifp->if_flags & IFF_UP)
xe_init(ifp->if_softc);
  999         return (0);
 1000 }
 1002 /*
 1003  * Notify the world which media we're using.
 1004  */
 1005 void
xe_mediastatus(ifp, ifmr)
 1007         struct ifnet *ifp;
 1008         struct ifmediareq *ifmr;
 1009 {
 1010         struct xe_softc *sc = ifp->if_softc;
mii_pollstat(&sc->sc_mii);
ifmr->ifm_status = sc->sc_mii.mii_media_status;
ifmr->ifm_active = sc->sc_mii.mii_media_active;
 1015 }
 1017 void
xe_reset(sc)
 1019         struct xe_softc *sc;
 1020 {
 1021         int s;
s = splnet();
xe_stop(sc);
xe_full_reset(sc);
xe_init(sc);
splx(s);
 1028 }
 1030 void
xe_watchdog(ifp)
 1032         struct ifnet *ifp;
 1033 {
 1034         struct xe_softc *sc = ifp->if_softc;
log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
 1037         ++sc->sc_arpcom.ac_if.if_oerrors;
xe_reset(sc);
 1040 }
 1042 void
xe_stop(sc)
 1044         register struct xe_softc *sc;
 1045 {
 1046         /* Disable interrupts. */
PAGE(sc, 0);
bus_space_write_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + CR, 0);
PAGE(sc, 1);
bus_space_write_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + IMR0, 0);
 1053         /* Power down, wait. */
PAGE(sc, 4);
bus_space_write_1(sc->sc_bst, sc->sc_bsh, sc->sc_offset + GP1, 0);
DELAY(40000);
 1058         /* Cancel watchdog timer. */
sc->sc_arpcom.ac_if.if_timer = 0;
 1060 }
 1062 void
xe_init(sc)
 1064         struct xe_softc *sc;
 1065 {
 1066         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
 1067         int s;
DPRINTF(XED_CONFIG, ("xe_init\n"));
s = splnet();
xe_set_address(sc);
 1075         /* Set current media. */
mii_mediachg(&sc->sc_mii);
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
splx(s);
 1081 }
 1083 /*
 1084  * Start outputting on the interface.
 1085  * Always called as splnet().
 1086  */
 1087 void
xe_start(ifp)
 1089         struct ifnet *ifp;
 1090 {
 1091         struct xe_softc *sc = ifp->if_softc;
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_size_t offset = sc->sc_offset;
 1095         unsigned int s, len, pad = 0;
 1096         struct mbuf *m0, *m;
u_int16_t space;
 1099         /* Don't transmit if interface is busy or not running. */
 1100         if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
 1101                 return;
 1103         /* Peek at the next packet. */
IFQ_POLL(&ifp->if_snd, m0);
 1105         if (m0 == 0)
 1106                 return;
 1108         /* We need to use m->m_pkthdr.len, so require the header. */
 1109         if (!(m0->m_flags & M_PKTHDR))
panic("xe_start: no header mbuf");
len = m0->m_pkthdr.len;
 1114         /* Pad to ETHER_MIN_LEN - ETHER_CRC_LEN. */
 1115         if (len < ETHER_MIN_LEN - ETHER_CRC_LEN)
pad = ETHER_MIN_LEN - ETHER_CRC_LEN - len;
PAGE(sc, 0);
space = bus_space_read_2(bst, bsh, offset + TSO0) & 0x7fff;
 1120         if (len + pad + 2 > space) {
DPRINTF(XED_FIFO,
 1122                     ("%s: not enough space in output FIFO (%d > %d)\n",
sc->sc_dev.dv_xname, len + pad + 2, space));
 1124                 return;
 1125         }
IFQ_DEQUEUE(&ifp->if_snd, m0);
 1129 #if NBPFILTER > 0
 1130         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
 1132 #endif
 1134         /*
 1135          * Do the output at splhigh() so that an interrupt from another device
 1136          * won't cause a FIFO underrun.
 1137          */
s = splhigh();
bus_space_write_2(bst, bsh, offset + TSO2, (u_int16_t)len + pad + 2);
bus_space_write_2(bst, bsh, offset + EDP, (u_int16_t)len + pad);
 1142         for (m = m0; m; ) {
 1143                 if (m->m_len > 1)
bus_space_write_raw_multi_2(bst, bsh, offset + EDP,
mtod(m, u_int8_t *), m->m_len & ~1);
 1146                 if (m->m_len & 1)
bus_space_write_1(bst, bsh, offset + EDP,
 1148                             *(mtod(m, u_int8_t *) + m->m_len - 1));
MFREE(m, m0);
m = m0;
 1151         }
 1152         if (sc->sc_flags & XEF_MOHAWK)
bus_space_write_1(bst, bsh, offset + CR, TX_PKT | ENABLE_INT);
 1154         else {
 1155                 for (; pad > 1; pad -= 2)
bus_space_write_2(bst, bsh, offset + EDP, 0);
 1157                 if (pad == 1)
bus_space_write_1(bst, bsh, offset + EDP, 0);
 1159         }
splx(s);
ifp->if_timer = 5;
 1164         ++ifp->if_opackets;
 1165 }
 1167 int
xe_ether_ioctl(ifp, cmd, data)
 1169         struct ifnet *ifp;
u_long cmd;
caddr_t data;
 1172 {
 1173         struct ifaddr *ifa = (struct ifaddr *)data;
 1174         struct xe_softc *sc = ifp->if_softc;
 1176         switch (cmd) {
 1177         case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
 1180                 switch (ifa->ifa_addr->sa_family) {
 1181 #ifdef INET
 1182                 case AF_INET:
xe_init(sc);
arp_ifinit(&sc->sc_arpcom, ifa);
 1185                         break;
 1186 #endif  /* INET */
 1188                 default:
xe_init(sc);
 1190                         break;
 1191                 }
 1192                 break;
 1194         default:
 1195                 return (EINVAL);
 1196         }
 1198         return (0);
 1199 }
 1201 int
xe_ioctl(ifp, command, data)
 1203         struct ifnet *ifp;
u_long command;
caddr_t data;
 1206 {
 1207         struct xe_softc *sc = ifp->if_softc;
 1208         struct ifreq *ifr = (struct ifreq *)data;
 1209         int s, error = 0;
s = splnet();
 1213         switch (command) {
 1214         case SIOCSIFADDR:
error = xe_ether_ioctl(ifp, command, data);
 1216                 break;
 1218         case SIOCSIFFLAGS:
sc->sc_all_mcasts = (ifp->if_flags & IFF_ALLMULTI) ? 1 : 0;
PAGE(sc, 0x42);
 1222                 if ((ifp->if_flags & IFF_PROMISC) ||
 1223                     (ifp->if_flags & IFF_ALLMULTI))
bus_space_write_1(sc->sc_bst, sc->sc_bsh,
sc->sc_offset + SWC1,
SWC1_PROMISC | SWC1_MCAST_PROM);
 1227                 else
bus_space_write_1(sc->sc_bst, sc->sc_bsh,
sc->sc_offset + SWC1, 0);
 1231                 /*
 1232                  * If interface is marked up and not running, then start it.
 1233                  * If it is marked down and running, stop it.
 1234                  * XXX If it's up then re-initialize it. This is so flags
 1235                  * such as IFF_PROMISC are handled.
 1236                  */
 1237                 if (ifp->if_flags & IFF_UP) {
xe_init(sc);
 1239                 } else {
 1240                         if (ifp->if_flags & IFF_RUNNING)
xe_stop(sc);
 1242                 }
 1243                 break;
 1245         case SIOCADDMULTI:
 1246         case SIOCDELMULTI:
sc->sc_all_mcasts = (ifp->if_flags & IFF_ALLMULTI) ? 1 : 0;
error = (command == SIOCADDMULTI) ?
ether_addmulti(ifr, &sc->sc_arpcom) :
ether_delmulti(ifr, &sc->sc_arpcom);
 1252                 if (error == ENETRESET) {
 1253                         /*
 1254                          * Multicast list has changed; set the hardware
 1255                          * filter accordingly.
 1256                          */
 1257                         if (!sc->sc_all_mcasts &&
 1258                             !(ifp->if_flags & IFF_PROMISC))
xe_set_address(sc);
 1261                         /*
 1262                          * xe_set_address() can turn on all_mcasts if we run
 1263                          * out of space, so check it again rather than else {}.
 1264                          */
 1265                         if (sc->sc_all_mcasts)
xe_init(sc);
error = 0;
 1268                 }
 1269                 break;
 1271         case SIOCSIFMEDIA:
 1272         case SIOCGIFMEDIA:
error =
ifmedia_ioctl(ifp, ifr, &sc->sc_mii.mii_media, command);
 1275                 break;
 1277         default:
error = EINVAL;
 1279         }
splx(s);
 1281         return (error);
 1282 }
 1284 void
xe_set_address(sc)
 1286         struct xe_softc *sc;
 1287 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_size_t offset = sc->sc_offset;
 1291         struct arpcom *arp = &sc->sc_arpcom;
 1292         struct ether_multi *enm;
 1293         struct ether_multistep step;
 1294         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
 1295         int i, page, pos, num;
PAGE(sc, 0x50);
 1298         for (i = 0; i < 6; i++) {
bus_space_write_1(bst, bsh, offset + IA + i,
sc->sc_arpcom.ac_enaddr[(sc->sc_flags & XEF_MOHAWK) ?
 1301                     5 - i : i]);
 1302         }
 1304         if (arp->ac_multicnt > 0) {
 1305                 if (arp->ac_multicnt > 9) {
PAGE(sc, 0x42);
bus_space_write_1(sc->sc_bst, sc->sc_bsh,
sc->sc_offset + SWC1,
SWC1_PROMISC | SWC1_MCAST_PROM);
 1310                         return;
 1311                 }
ETHER_FIRST_MULTI(step, arp, enm);
pos = IA + 6;
 1316                 for (page = 0x50, num = arp->ac_multicnt; num > 0 && enm;
num--) {
 1318                         if (bcmp(enm->enm_addrlo, enm->enm_addrhi,
 1319                             sizeof(enm->enm_addrlo)) != 0) {
 1320                                 /*
 1321                                  * The multicast address is really a range;
 1322                                  * it's easier just to accept all multicasts.
 1323                                  * XXX should we be setting IFF_ALLMULTI here?
 1324                                  */
ifp->if_flags |= IFF_ALLMULTI;
sc->sc_all_mcasts=1;
 1327                                 break;
 1328                         }
 1330                         for (i = 0; i < 6; i++) {
bus_space_write_1(bst, bsh, offset + pos,
enm->enm_addrlo[
 1333                                     (sc->sc_flags & XEF_MOHAWK) ? 5 - i : i]);
 1335                                 if (++pos > 15) {
pos = IA;
page++;
PAGE(sc, page);
 1339                                 }
 1340                         }
 1341                 }
 1342         }
 1343 }
 1345 void
xe_cycle_power(sc)
 1347         struct xe_softc *sc;
 1348 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_size_t offset = sc->sc_offset;
PAGE(sc, 4);
DELAY(1);
bus_space_write_1(bst, bsh, offset + GP1, 0);
DELAY(40000);
 1357         if (sc->sc_flags & XEF_MOHAWK)
bus_space_write_1(bst, bsh, offset + GP1, POWER_UP);
 1359         else
 1360                 /* XXX What is bit 2 (aka AIC)? */
bus_space_write_1(bst, bsh, offset + GP1, POWER_UP | 4);
DELAY(20000);
 1363 }
 1365 void
xe_full_reset(sc)
 1367         struct xe_softc *sc;
 1368 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_size_t offset = sc->sc_offset;
 1373         /* Do an as extensive reset as possible on all functions. */
xe_cycle_power(sc);
bus_space_write_1(bst, bsh, offset + CR, SOFT_RESET);
DELAY(20000);
bus_space_write_1(bst, bsh, offset + CR, 0);
DELAY(20000);
 1379         if (sc->sc_flags & XEF_MOHAWK) {
PAGE(sc, 4);
 1381                 /*
 1382                  * Drive GP1 low to power up ML6692 and GP2 high to power up
 1383                  * the 10MHz chip.  XXX What chip is that?  The phy?
 1384                  */
bus_space_write_1(bst, bsh, offset + GP0,
GP1_OUT | GP2_OUT | GP2_WR);
 1387         }
DELAY(500000);
 1390         /* Get revision information.  XXX Symbolic constants. */
sc->sc_rev = bus_space_read_1(bst, bsh, offset + BV) &
 1392             ((sc->sc_flags & XEF_MOHAWK) ? 0x70 : 0x30) >> 4;
 1394         /* Media selection.  XXX Maybe manual overriding too? */
 1395         if (!(sc->sc_flags & XEF_MOHAWK)) {
PAGE(sc, 4);
 1397                 /*
 1398                  * XXX I have no idea what this really does, it is from the
 1399                  * Linux driver.
 1400                  */
bus_space_write_1(bst, bsh, offset + GP0, GP1_OUT);
 1402         }
DELAY(40000);
 1405         /* Setup the ethernet interrupt mask. */
PAGE(sc, 1);
bus_space_write_1(bst, bsh, offset + IMR0,
ISR_TX_OFLOW | ISR_PKT_TX | ISR_MAC_INT | /* ISR_RX_EARLY | */
ISR_RX_FULL | ISR_RX_PKT_REJ | ISR_FORCED_INT);
 1410 #if 0
bus_space_write_1(bst, bsh, offset + IMR0, 0xff);
 1412 #endif
 1413         if (!(sc->sc_flags & XEF_DINGO))
 1414                 /* XXX What is this?  Not for Dingo at least. */
bus_space_write_1(bst, bsh, offset + IMR1, 1);
 1417         /*
 1418          * Disable source insertion.
 1419          * XXX Dingo does not have this bit, but Linux does it unconditionally.
 1420          */
 1421         if (!(sc->sc_flags & XEF_DINGO)) {
PAGE(sc, 0x42);
bus_space_write_1(bst, bsh, offset + SWC0, 0x20);
 1424         }
 1426         /* Set the local memory dividing line. */
 1427         if (sc->sc_rev != 1) {
PAGE(sc, 2);
 1429                 /* XXX Symbolic constant preferrable. */
bus_space_write_2(bst, bsh, offset + RBS0, 0x2000);
 1431         }
xe_set_address(sc);
 1435         /*
 1436          * Apparently the receive byte pointer can be bad after a reset, so
 1437          * we hardwire it correctly.
 1438          */
PAGE(sc, 0);
bus_space_write_2(bst, bsh, offset + DO0, DO_CHG_OFFSET);
 1442         /* Setup ethernet MAC registers. XXX Symbolic constants. */
PAGE(sc, 0x40);
bus_space_write_1(bst, bsh, offset + RX0MSK,
PKT_TOO_LONG | CRC_ERR | RX_OVERRUN | RX_ABORT | RX_OK);
bus_space_write_1(bst, bsh, offset + TX0MSK,
CARRIER_LOST | EXCESSIVE_COLL | TX_UNDERRUN | LATE_COLLISION |
SQE | TX_ABORT | TX_OK);
 1449         if (!(sc->sc_flags & XEF_DINGO))
 1450                 /* XXX From Linux, dunno what 0xb0 means. */
bus_space_write_1(bst, bsh, offset + TX1MSK, 0xb0);
bus_space_write_1(bst, bsh, offset + RXST0, 0);
bus_space_write_1(bst, bsh, offset + TXST0, 0);
bus_space_write_1(bst, bsh, offset + TXST1, 0);
 1456         /* Enable MII function if available. */
 1457         if (LIST_FIRST(&sc->sc_mii.mii_phys)) {
PAGE(sc, 2);
bus_space_write_1(bst, bsh, offset + MSR,
bus_space_read_1(bst, bsh, offset + MSR) | SELECT_MII);
DELAY(20000);
 1462         } else {
PAGE(sc, 0);
 1465                 /* XXX Do we need to do this? */
PAGE(sc, 0x42);
bus_space_write_1(bst, bsh, offset + SWC1, SWC1_AUTO_MEDIA);
DELAY(50000);
 1470                 /* XXX Linux probes the media here. */
 1471         }
 1473         /* Configure the LED registers. */
PAGE(sc, 2);
 1476         /* XXX This is not good for 10base2. */
bus_space_write_1(bst, bsh, offset + LED,
LED_TX_ACT << LED1_SHIFT | LED_10MB_LINK << LED0_SHIFT);
 1479         if (sc->sc_flags & XEF_DINGO)
bus_space_write_1(bst, bsh, offset + LED3,
LED_100MB_LINK << LED3_SHIFT);
 1483         /* Enable receiver and go online. */
PAGE(sc, 0x40);
bus_space_write_1(bst, bsh, offset + CMD0, ENABLE_RX | ONLINE);
 1487 #if 0
 1488         /* XXX Linux does this here - is it necessary? */
PAGE(sc, 1);
bus_space_write_1(bst, bsh, offset + IMR0, 0xff);
 1491         if (!(sc->sc_flags & XEF_DINGO))
 1492                 /* XXX What is this?  Not for Dingo at least. */
bus_space_write_1(bst, bsh, offset + IMR1, 1);
 1494 #endif
 1496        /* Enable interrupts. */
PAGE(sc, 0);
bus_space_write_1(bst, bsh, offset + CR, ENABLE_INT);
 1500         /* XXX This is pure magic for me, found in the Linux driver. */
 1501         if ((sc->sc_flags & (XEF_DINGO | XEF_MODEM)) == XEF_MODEM) {
 1502                 if ((bus_space_read_1(bst, bsh, offset + 0x10) & 0x01) == 0)
 1503                         /* Unmask the master interrupt bit. */
bus_space_write_1(bst, bsh, offset + 0x10, 0x11);
 1505         }
 1507         /*
 1508          * The Linux driver says this:
 1509          * We should switch back to page 0 to avoid a bug in revision 0
 1510          * where regs with offset below 8 can't be read after an access
 1511          * to the MAC registers.
 1512          */
PAGE(sc, 0);
 1514 }
 1516 #ifdef XEDEBUG
 1517 void
xe_reg_dump(sc)
 1519         struct xe_softc *sc;
 1520 {
 1521         int page, i;
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_size_t offset = sc->sc_offset;
printf("%x: Common registers: ", sc->sc_dev.dv_xname);
 1527         for (i = 0; i < 8; i++) {
printf(" %2.2x", bus_space_read_1(bst, bsh, offset + i));
 1529         }
printf("\n");
 1532         for (page = 0; page < 8; page++) {
printf("%s: Register page %2.2x: ", sc->sc_dev.dv_xname, page);
PAGE(sc, page);
 1535                 for (i = 8; i < 16; i++) {
printf(" %2.2x",
bus_space_read_1(bst, bsh, offset + i));
 1538                 }
printf("\n");
 1540         }
 1542         for (page = 0x40; page < 0x5f; page++) {
 1543                 if (page == 0x43 || (page >= 0x46 && page <= 0x4f) ||
 1544                     (page >= 0x51 && page <= 0x5e))
 1545                         continue;
printf("%s: Register page %2.2x: ", sc->sc_dev.dv_xname, page);
PAGE(sc, page);
 1548                 for (i = 8; i < 16; i++) {
printf(" %2.2x",
bus_space_read_1(bst, bsh, offset + i));
 1551                 }
printf("\n");
 1553         }
 1554 }
 1555 #endif  /* XEDEBUG */