xref: /netbsd-src/sys/dev/pcmcia/if_mbe_pcmcia.c (revision 8bc54e5be648e06e7c6b48f7611f8bccfda032d4)
1 /*	$NetBSD: if_mbe_pcmcia.c,v 1.47 2016/07/07 06:55:42 msaitoh Exp $	*/
2 
3 /*-
4  * Copyright (c) 1998, 2000, 2004 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Enami Tsugutomo.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: if_mbe_pcmcia.c,v 1.47 2016/07/07 06:55:42 msaitoh Exp $");
34 
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/device.h>
38 #include <sys/socket.h>
39 
40 #include <net/if.h>
41 #include <net/if_ether.h>
42 #include <net/if_media.h>
43 
44 #include <sys/intr.h>
45 #include <sys/bus.h>
46 
47 #include <dev/ic/mb86960reg.h>
48 #include <dev/ic/mb86960var.h>
49 
50 #include <dev/pcmcia/pcmciareg.h>
51 #include <dev/pcmcia/pcmciavar.h>
52 #include <dev/pcmcia/pcmciadevs.h>
53 
54 int	mbe_pcmcia_match(device_t, cfdata_t, void *);
55 int	mbe_pcmcia_validate_config(struct pcmcia_config_entry *);
56 void	mbe_pcmcia_attach(device_t, device_t, void *);
57 int	mbe_pcmcia_detach(device_t, int);
58 
59 struct mbe_pcmcia_softc {
60 	struct	mb86960_softc sc_mb86960;	/* real "mb" softc */
61 
62 	struct	pcmcia_function *sc_pf;		/* our PCMCIA function */
63 	void	*sc_ih;				/* interrupt cookie */
64 
65 	int	sc_state;
66 #define	MBE_PCMCIA_ATTACHED	3
67 };
68 
69 CFATTACH_DECL_NEW(mbe_pcmcia, sizeof(struct mbe_pcmcia_softc),
70     mbe_pcmcia_match, mbe_pcmcia_attach, mbe_pcmcia_detach, mb86960_activate);
71 
72 int	mbe_pcmcia_enable(struct mb86960_softc *);
73 void	mbe_pcmcia_disable(struct mb86960_softc *);
74 
75 struct mbe_pcmcia_get_enaddr_args {
76 	uint8_t enaddr[ETHER_ADDR_LEN];
77 	int maddr;
78 };
79 int	mbe_pcmcia_get_enaddr_from_cis(struct pcmcia_tuple *, void *);
80 int	mbe_pcmcia_get_enaddr_from_mem(struct mbe_pcmcia_softc *,
81 	    struct mbe_pcmcia_get_enaddr_args *);
82 int	mbe_pcmcia_get_enaddr_from_io(struct mbe_pcmcia_softc *,
83 	    struct mbe_pcmcia_get_enaddr_args *);
84 
85 static const struct mbe_pcmcia_product {
86 	struct pcmcia_product mpp_product;
87 	int		mpp_enet_maddr;
88 	int		mpp_flags;
89 #define MBH10302	0x0001			/* FUJITSU MBH10302 */
90 } mbe_pcmcia_products[] = {
91 	{ { PCMCIA_VENDOR_TDK, PCMCIA_PRODUCT_TDK_LAK_CD021BX,
92 	    PCMCIA_CIS_TDK_LAK_CD021BX },
93 	  -1, 0 },
94 
95 	{ { PCMCIA_VENDOR_TDK, PCMCIA_PRODUCT_TDK_LAK_CF010,
96 	    PCMCIA_CIS_TDK_LAK_CF010 },
97 	  -1, 0 },
98 
99 #if 0 /* XXX 86960-based? */
100 	{ { PCMCIA_VENDOR_TDK, PCMCIA_PRODUCT_TDK_LAK_DFL9610,
101 	    PCMCIA_CIS_TDK_DFL9610 },
102 	  -1, MBH10302 /* XXX */ },
103 #endif
104 
105 	{ { PCMCIA_VENDOR_CONTEC, PCMCIA_PRODUCT_CONTEC_CNETPC,
106 	    PCMCIA_CIS_CONTEC_CNETPC },
107 	  -1, 0 },
108 
109 	{ { PCMCIA_VENDOR_FUJITSU, PCMCIA_PRODUCT_FUJITSU_LA501,
110 	    PCMCIA_CIS_FUJITSU_LA501 },
111 	  -1, 0 },
112 
113 	{ { PCMCIA_VENDOR_FUJITSU, PCMCIA_PRODUCT_FUJITSU_FMV_J181,
114 	    PCMCIA_CIS_FUJITSU_FMV_J181 },
115 	  -1, MBH10302 },
116 
117 	{ { PCMCIA_VENDOR_FUJITSU, PCMCIA_PRODUCT_FUJITSU_FMV_J182,
118 	    PCMCIA_CIS_FUJITSU_FMV_J182 },
119 	  0xf2c, 0 },
120 
121 	{ { PCMCIA_VENDOR_FUJITSU, PCMCIA_PRODUCT_FUJITSU_FMV_J182A,
122 	    PCMCIA_CIS_FUJITSU_FMV_J182A },
123 	  0x1cc, 0 },
124 
125 	{ { PCMCIA_VENDOR_FUJITSU, PCMCIA_PRODUCT_FUJITSU_ITCFJ182A,
126 	    PCMCIA_CIS_FUJITSU_ITCFJ182A },
127 	  0x1cc, 0 },
128 
129 	{ { PCMCIA_VENDOR_FUJITSU, PCMCIA_PRODUCT_FUJITSU_LA10S,
130 	    PCMCIA_CIS_FUJITSU_LA10S },
131 	  -1, 0 },
132 
133 	{ { PCMCIA_VENDOR_RATOC, PCMCIA_PRODUCT_RATOC_REX_R280,
134 	    PCMCIA_CIS_RATOC_REX_R280 },
135 	  0x1fc, 0 },
136 };
137 static const size_t mbe_pcmcia_nproducts = __arraycount(mbe_pcmcia_products);
138 
139 int
mbe_pcmcia_match(device_t parent,cfdata_t cf,void * aux)140 mbe_pcmcia_match(device_t parent, cfdata_t cf, void *aux)
141 {
142 	struct pcmcia_attach_args *pa = aux;
143 
144 	if (pcmcia_product_lookup(pa, mbe_pcmcia_products,
145 	    mbe_pcmcia_nproducts, sizeof(mbe_pcmcia_products[0]), NULL))
146 		return 1;
147 	return 0;
148 }
149 
150 int
mbe_pcmcia_validate_config(struct pcmcia_config_entry * cfe)151 mbe_pcmcia_validate_config(struct pcmcia_config_entry *cfe)
152 {
153 
154 	if (cfe->iftype != PCMCIA_IFTYPE_IO || cfe->num_iospace < 1)
155 		return EINVAL;
156 	return 0;
157 }
158 
159 void
mbe_pcmcia_attach(device_t parent,device_t self,void * aux)160 mbe_pcmcia_attach(device_t parent, device_t self, void *aux)
161 {
162 	struct mbe_pcmcia_softc *psc = device_private(self);
163 	struct mb86960_softc *sc = &psc->sc_mb86960;
164 	struct pcmcia_attach_args *pa = aux;
165 	struct pcmcia_config_entry *cfe;
166 	struct mbe_pcmcia_get_enaddr_args pgea;
167 	const struct mbe_pcmcia_product *mpp;
168 	int error;
169 
170 	sc->sc_dev = self;
171 	psc->sc_pf = pa->pf;
172 
173 	error = pcmcia_function_configure(pa->pf, mbe_pcmcia_validate_config);
174 	if (error) {
175 		aprint_error_dev(self, "configure failed, error=%d\n", error);
176 		return;
177 	}
178 
179 	cfe = pa->pf->cfe;
180 	sc->sc_bst = cfe->iospace[0].handle.iot;
181 	sc->sc_bsh = cfe->iospace[0].handle.ioh;
182 
183 	mpp = pcmcia_product_lookup(pa, mbe_pcmcia_products,
184 	    mbe_pcmcia_nproducts, sizeof(mbe_pcmcia_products[0]), NULL);
185 	if (!mpp)
186 		panic("%s: impossible", __func__);
187 
188 	/* Read station address from io/mem or CIS. */
189 	if (mpp->mpp_enet_maddr >= 0) {
190 		pgea.maddr = mpp->mpp_enet_maddr;
191 		if (mbe_pcmcia_get_enaddr_from_mem(psc, &pgea) != 0) {
192 			aprint_error_dev(self, "couldn't get ethernet address "
193 			    "from memory\n");
194 			goto fail;
195 		}
196 	} else if (mpp->mpp_flags & MBH10302) {
197 		bus_space_write_1(sc->sc_bst, sc->sc_bsh, FE_MBH0 ,
198 				  FE_MBH0_MASK | FE_MBH0_INTR_ENABLE);
199 		if (mbe_pcmcia_get_enaddr_from_io(psc, &pgea) != 0) {
200 			aprint_error_dev(self,
201 			    "couldn't get ethernet address from i/o\n");
202 			goto fail;
203 		}
204 	} else {
205 		if (pa->pf->pf_funce_lan_nidlen != ETHER_ADDR_LEN) {
206 			aprint_error_dev(self,
207 			    "couldn't get ethernet address from CIS\n");
208 			goto fail;
209 		}
210 		memcpy(pgea.enaddr, pa->pf->pf_funce_lan_nid, ETHER_ADDR_LEN);
211 	}
212 
213 	/* Perform generic initialization. */
214 	if (mpp->mpp_flags & MBH10302)
215 		sc->sc_flags |= FE_FLAGS_MB86960;
216 
217 	sc->sc_enable = mbe_pcmcia_enable;
218 	sc->sc_disable = mbe_pcmcia_disable;
219 
220 	error = mbe_pcmcia_enable(sc);
221 	if (error)
222 		goto fail;
223 
224 	mb86960_attach(sc, pgea.enaddr);
225 	mb86960_config(sc, NULL, 0, 0);
226 
227 	mbe_pcmcia_disable(sc);
228 	psc->sc_state = MBE_PCMCIA_ATTACHED;
229 	return;
230 
231 fail:
232 	pcmcia_function_unconfigure(pa->pf);
233 }
234 
235 int
mbe_pcmcia_detach(device_t self,int flags)236 mbe_pcmcia_detach(device_t self, int flags)
237 {
238 	struct mbe_pcmcia_softc *psc = device_private(self);
239 	int error;
240 
241 	if (psc->sc_state != MBE_PCMCIA_ATTACHED)
242 		return 0;
243 
244 	error = mb86960_detach(&psc->sc_mb86960);
245 	if (error)
246 		return error;
247 
248 	pcmcia_function_unconfigure(psc->sc_pf);
249 
250 	return 0;
251 }
252 
253 int
mbe_pcmcia_enable(struct mb86960_softc * sc)254 mbe_pcmcia_enable(struct mb86960_softc *sc)
255 {
256 	struct mbe_pcmcia_softc *psc = (struct mbe_pcmcia_softc *)sc;
257 	int error;
258 
259 	/* Establish the interrupt handler. */
260 	psc->sc_ih = pcmcia_intr_establish(psc->sc_pf, IPL_NET, mb86960_intr,
261 	    sc);
262 	if (!psc->sc_ih)
263 		return EIO;
264 
265 	error = pcmcia_function_enable(psc->sc_pf);
266 	if (error) {
267 		pcmcia_intr_disestablish(psc->sc_pf, psc->sc_ih);
268 		psc->sc_ih = 0;
269 	}
270 
271 	return error;
272 }
273 
274 void
mbe_pcmcia_disable(struct mb86960_softc * sc)275 mbe_pcmcia_disable(struct mb86960_softc *sc)
276 {
277 	struct mbe_pcmcia_softc *psc = (struct mbe_pcmcia_softc *)sc;
278 
279 	pcmcia_function_disable(psc->sc_pf);
280 	pcmcia_intr_disestablish(psc->sc_pf, psc->sc_ih);
281 	psc->sc_ih = 0;
282 }
283 
284 int
mbe_pcmcia_get_enaddr_from_io(struct mbe_pcmcia_softc * psc,struct mbe_pcmcia_get_enaddr_args * ea)285 mbe_pcmcia_get_enaddr_from_io(struct mbe_pcmcia_softc *psc,
286     struct mbe_pcmcia_get_enaddr_args *ea)
287 {
288 	struct mb86960_softc *sc = &psc->sc_mb86960;
289 	int i;
290 
291 	for (i = 0; i < ETHER_ADDR_LEN; i++)
292 		ea->enaddr[i] = bus_space_read_1(sc->sc_bst, sc->sc_bsh,
293 		    FE_MBH_ENADDR + i);
294 	return 0;
295 }
296 
297 int
mbe_pcmcia_get_enaddr_from_mem(struct mbe_pcmcia_softc * psc,struct mbe_pcmcia_get_enaddr_args * ea)298 mbe_pcmcia_get_enaddr_from_mem(struct mbe_pcmcia_softc *psc,
299     struct mbe_pcmcia_get_enaddr_args *ea)
300 {
301 	struct mb86960_softc *sc = &psc->sc_mb86960;
302 	struct pcmcia_mem_handle pcmh;
303 	bus_size_t offset;
304 	int i, mwindow, rv = 1;
305 
306 	if (ea->maddr < 0)
307 		goto bad_memaddr;
308 
309 	if (pcmcia_mem_alloc(psc->sc_pf, ETHER_ADDR_LEN * 2, &pcmh)) {
310 		aprint_error_dev(sc->sc_dev, "can't alloc mem for enet addr\n");
311 		goto memalloc_failed;
312 	}
313 
314 	if (pcmcia_mem_map(psc->sc_pf, PCMCIA_MEM_ATTR, ea->maddr,
315 	    ETHER_ADDR_LEN * 2, &pcmh, &offset, &mwindow)) {
316 		aprint_error_dev(sc->sc_dev, "can't map mem for enet addr\n");
317 		goto memmap_failed;
318 	}
319 
320 	for (i = 0; i < ETHER_ADDR_LEN; i++)
321 		ea->enaddr[i] = bus_space_read_1(pcmh.memt, pcmh.memh,
322 		    offset + (i * 2));
323 
324 	rv = 0;
325 	pcmcia_mem_unmap(psc->sc_pf, mwindow);
326 memmap_failed:
327 	pcmcia_mem_free(psc->sc_pf, &pcmh);
328 memalloc_failed:
329 bad_memaddr:
330 
331 	return rv;
332 }
333