Home | History | Annotate | Line # | Download | only in pcmcia
if_ep_pcmcia.c revision 1.6 
      1 /*	$NetBSD: if_ep_pcmcia.c,v 1.6 1998/03/09 21:52:31 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1997 Marc Horowitz.  All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  * 3. All advertising materials mentioning features or use of this software
     15  *    must display the following acknowledgement:
     16  *	This product includes software developed by Marc Horowitz.
     17  * 4. The name of the author may not be used to endorse or promote products
     18  *    derived from this software without specific prior written permission.
     19  *
     20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include "bpfilter.h"
     33 
     34 #include <sys/param.h>
     35 #include <sys/systm.h>
     36 #include <sys/mbuf.h>
     37 #include <sys/socket.h>
     38 #include <sys/ioctl.h>
     39 #include <sys/errno.h>
     40 #include <sys/syslog.h>
     41 #include <sys/select.h>
     42 #include <sys/device.h>
     43 
     44 #include <net/if.h>
     45 #include <net/if_dl.h>
     46 #include <net/if_ether.h>
     47 #include <net/if_media.h>
     48 
     49 #ifdef INET
     50 #include <netinet/in.h>
     51 #include <netinet/in_systm.h>
     52 #include <netinet/in_var.h>
     53 #include <netinet/ip.h>
     54 #include <netinet/if_inarp.h>
     55 #endif
     56 
     57 #ifdef NS
     58 #include <netns/ns.h>
     59 #include <netns/ns_if.h>
     60 #endif
     61 
     62 #if NBPFILTER > 0
     63 #include <net/bpf.h>
     64 #include <net/bpfdesc.h>
     65 #endif
     66 
     67 #include <machine/cpu.h>
     68 #include <machine/bus.h>
     69 #include <machine/intr.h>
     70 
     71 #include <dev/ic/elink3var.h>
     72 #include <dev/ic/elink3reg.h>
     73 
     74 #include <dev/pcmcia/pcmciareg.h>
     75 #include <dev/pcmcia/pcmciavar.h>
     76 
     77 #define	PCMCIA_MANUFACTURER_3COM	0x101
     78 #define	PCMCIA_PRODUCT_3COM_3C562	0x562
     79 #define	PCMCIA_PRODUCT_3COM_3C589	0x589
     80 
     81 #ifdef __BROKEN_INDIRECT_CONFIG
     82 int	ep_pcmcia_match __P((struct device *, void *, void *));
     83 #else
     84 int	ep_pcmcia_match __P((struct device *, struct cfdata *, void *));
     85 #endif
     86 void	ep_pcmcia_attach __P((struct device *, struct device *, void *));
     87 
     88 int	ep_pcmcia_get_enaddr __P((struct pcmcia_tuple *, void *));
     89 int	ep_pcmcia_enable __P((struct ep_softc *));
     90 void	ep_pcmcia_disable __P((struct ep_softc *));
     91 
     92 struct ep_pcmcia_softc {
     93 	struct ep_softc sc_ep;			/* real "ep" softc */
     94 
     95 	/* PCMCIA-specific goo */
     96 	struct pcmcia_io_handle sc_pcioh;	/* PCMCIA i/o space info */
     97 	int sc_io_window;			/* our i/o window */
     98 	struct pcmcia_function *sc_pf;		/* our PCMCIA function */
     99 };
    100 
    101 struct cfattach ep_pcmcia_ca = {
    102 	sizeof(struct ep_pcmcia_softc), ep_pcmcia_match, ep_pcmcia_attach
    103 };
    104 
    105 int
    106 ep_pcmcia_match(parent, match, aux)
    107 	struct device *parent;
    108 #ifdef __BROKEN_INDIRECT_CONFIG
    109 	void *match;
    110 #else
    111 	struct cfdata *match;
    112 #endif
    113 	void *aux;
    114 {
    115 	struct pcmcia_attach_args *pa = aux;
    116 
    117 	if (pa->manufacturer == PCMCIA_MANUFACTURER_3COM) {
    118 		switch (pa->product) {
    119 		case PCMCIA_PRODUCT_3COM_3C562:
    120 		case PCMCIA_PRODUCT_3COM_3C589:
    121 			if (pa->pf->number == 0)
    122 				return (1);
    123 		}
    124 	}
    125 
    126 	return (0);
    127 }
    128 
    129 int
    130 ep_pcmcia_enable(sc)
    131 	struct ep_softc *sc;
    132 {
    133 	struct ep_pcmcia_softc *psc = (struct ep_pcmcia_softc *) sc;
    134 	struct pcmcia_function *pf = psc->sc_pf;
    135 	int ret;
    136 
    137 	/* establish the interrupt. */
    138 	sc->sc_ih = pcmcia_intr_establish(pf, IPL_NET, epintr, sc);
    139 	if (sc->sc_ih == NULL) {
    140 		printf("%s: couldn't establish interrupt\n",
    141 		    sc->sc_dev.dv_xname);
    142 		return (1);
    143 	}
    144 
    145 	if ((ret = pcmcia_function_enable(pf)))
    146 	    return(ret);
    147 
    148 	if (psc->sc_pf->sc->card.product == PCMCIA_PRODUCT_3COM_3C562) {
    149 		int reg;
    150 
    151 		/* turn off the serial-disable bit */
    152 
    153 		reg = pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION);
    154 		if (reg & 0x08) {
    155 		    reg &= ~0x08;
    156 		    pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
    157 		}
    158 
    159 	}
    160 
    161 	return (ret);
    162 }
    163 
    164 void
    165 ep_pcmcia_disable(sc)
    166 	struct ep_softc *sc;
    167 {
    168 	struct ep_pcmcia_softc *psc = (struct ep_pcmcia_softc *) sc;
    169 
    170 	pcmcia_function_disable(psc->sc_pf);
    171 
    172 	pcmcia_intr_disestablish(psc->sc_pf, sc->sc_ih);
    173 }
    174 
    175 void
    176 ep_pcmcia_attach(parent, self, aux)
    177 	struct device  *parent, *self;
    178 	void           *aux;
    179 {
    180 	struct ep_pcmcia_softc *psc = (void *) self;
    181 	struct ep_softc *sc = &psc->sc_ep;
    182 	struct pcmcia_attach_args *pa = aux;
    183 	struct pcmcia_config_entry *cfe;
    184 	int i;
    185 	u_int8_t myla[ETHER_ADDR_LEN];
    186 	u_int8_t *enaddr;
    187 	char *model;
    188 
    189 	psc->sc_pf = pa->pf;
    190 	cfe = pa->pf->cfe_head.sqh_first;
    191 
    192 	/* Enable the card. */
    193 	pcmcia_function_init(pa->pf, cfe);
    194 	if (ep_pcmcia_enable(sc))
    195 		printf(": function enable failed\n");
    196 
    197 	sc->enabled = 1;
    198 
    199 	if (cfe->num_memspace != 0)
    200 		printf(": unexpected number of memory spaces %d should be 0\n",
    201 		    cfe->num_memspace);
    202 
    203 	if (cfe->num_iospace != 1)
    204 		printf(": unexpected number of I/O spaces %d should be 1\n",
    205 		    cfe->num_iospace);
    206 
    207 	if (pa->product == PCMCIA_PRODUCT_3COM_3C562) {
    208 		bus_addr_t maxaddr = (pa->pf->sc->iobase + pa->pf->sc->iosize);
    209 
    210 		for (i = pa->pf->sc->iobase; i < maxaddr; i += 0x10) {
    211 			/*
    212 			 * the 3c562 can only use 0x??00-0x??7f
    213 			 * according to the Linux driver
    214 			 */
    215 			if (i & 0x80)
    216 				continue;
    217 			if (pcmcia_io_alloc(pa->pf, i, cfe->iospace[0].length,
    218 			    0, &psc->sc_pcioh) == 0)
    219 				break;
    220 		}
    221 		if (i >= maxaddr) {
    222 			printf(": can't allocate i/o space\n");
    223 			return;
    224 		}
    225 	} else {
    226 		if (pcmcia_io_alloc(pa->pf, 0, cfe->iospace[0].length,
    227 		    cfe->iospace[0].length, &psc->sc_pcioh))
    228 			printf(": can't allocate i/o space\n");
    229 	}
    230 
    231 	sc->sc_iot = psc->sc_pcioh.iot;
    232 	sc->sc_ioh = psc->sc_pcioh.ioh;
    233 
    234 	if (pcmcia_io_map(pa->pf, ((cfe->flags & PCMCIA_CFE_IO16) ?
    235 	    PCMCIA_WIDTH_IO16 : PCMCIA_WIDTH_IO8), 0, cfe->iospace[0].length,
    236 	    &psc->sc_pcioh, &psc->sc_io_window)) {
    237 		printf(": can't map i/o space\n");
    238 		return;
    239 	}
    240 	if (pa->product == PCMCIA_PRODUCT_3COM_3C562) {
    241 		/*
    242 		 * 3c562a-c use this; 3c562d does it in the regular way.
    243 		 * we might want to check the revision and produce a warning
    244 		 * in the future.
    245 		 */
    246 		if (pcmcia_scan_cis(parent, ep_pcmcia_get_enaddr, myla) != 1)
    247 			enaddr = NULL;
    248 		else
    249 			enaddr = myla;
    250 	} else {
    251 		enaddr = NULL;
    252 	}
    253 
    254 	sc->bustype = EP_BUS_PCMCIA;
    255 
    256 	switch (pa->product) {
    257 	case PCMCIA_PRODUCT_3COM_3C589:
    258 		model = "3Com 3C589 Ethernet";
    259 		break;
    260 	case PCMCIA_PRODUCT_3COM_3C562:
    261 		model = "3Com 3C562 Ethernet";
    262 		break;
    263 	default:
    264 		model = "3Com Ethernet, model unknown";
    265 		break;
    266 	}
    267 
    268 	printf(": %s\n", model);
    269 
    270 	sc->enable = ep_pcmcia_enable;
    271 	sc->disable = ep_pcmcia_disable;
    272 
    273 	epconfig(sc, EP_CHIPSET_3C509, enaddr);
    274 
    275 	sc->enabled = 0;
    276 
    277 	ep_pcmcia_disable(sc);
    278 }
    279 
    280 int
    281 ep_pcmcia_get_enaddr(tuple, arg)
    282 	struct pcmcia_tuple *tuple;
    283 	void *arg;
    284 {
    285 	u_int8_t *myla = arg;
    286 	int i;
    287 
    288 	/* this is 3c562a-c magic */
    289 	if (tuple->code == 0x88) {
    290 		if (tuple->length < ETHER_ADDR_LEN)
    291 			return (0);
    292 
    293 		for (i = 0; i < ETHER_ADDR_LEN; i += 2) {
    294 			myla[i] = pcmcia_tuple_read_1(tuple, i + 1);
    295 			myla[i + 1] = pcmcia_tuple_read_1(tuple, i);
    296 		}
    297 
    298 		return (1);
    299 	}
    300 	return (0);
    301 }
    302