1 /* $NetBSD: if_an_pcmcia.c,v 1.17 2004/01/28 15:07:52 onoe Exp $ */
2
3 /*-
4 * Copyright (c) 2000 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Atsushi Onoe
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 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39 #include <sys/cdefs.h>
40 __KERNEL_RCSID(0, "$NetBSD: if_an_pcmcia.c,v 1.17 2004/01/28 15:07:52 onoe Exp $");
41
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/callout.h>
45 #include <sys/mbuf.h>
46 #include <sys/socket.h>
47 #include <sys/ioctl.h>
48 #include <sys/errno.h>
49 #include <sys/syslog.h>
50 #include <sys/select.h>
51 #include <sys/device.h>
52
53 #include <net/if.h>
54 #include <net/if_dl.h>
55 #include <net/if_ether.h>
56 #include <net/if_media.h>
57
58 #include <net80211/ieee80211_var.h>
59 #include <net80211/ieee80211_compat.h>
60
61 #include <machine/cpu.h>
62 #include <machine/bus.h>
63 #include <machine/intr.h>
64
65 #include <dev/ic/anreg.h>
66 #include <dev/ic/anvar.h>
67
68 #include <dev/pcmcia/pcmciareg.h>
69 #include <dev/pcmcia/pcmciavar.h>
70 #include <dev/pcmcia/pcmciadevs.h>
71
72 static int an_pcmcia_match __P((struct device *, struct cfdata *, void *));
73 static void an_pcmcia_attach __P((struct device *, struct device *, void *));
74 static int an_pcmcia_detach __P((struct device *, int));
75 static int an_pcmcia_enable __P((struct an_softc *));
76 static void an_pcmcia_disable __P((struct an_softc *));
77
78 struct an_pcmcia_softc {
79 struct an_softc sc_an; /* real "an" softc */
80
81 /* PCMCIA-specific goo */
82 struct pcmcia_io_handle sc_pcioh; /* PCMCIA i/o space info */
83 int sc_io_window; /* our i/o window */
84 struct pcmcia_function *sc_pf; /* our PCMCIA function */
85 void *sc_ih; /* interrupt handle */
86 void *sc_powerhook; /* power hook descriptor */
87 };
88
89 CFATTACH_DECL(an_pcmcia, sizeof(struct an_pcmcia_softc),
90 an_pcmcia_match, an_pcmcia_attach, an_pcmcia_detach, an_activate);
91
92 static struct an_pcmcia_product {
93 u_int32_t app_vendor; /* vendor ID */
94 u_int32_t app_product; /* product ID */
95 const char *app_cisinfo[4]; /* CIS information */
96 const char *app_name; /* product name */
97 } an_pcmcia_products[] = {
98 { PCMCIA_VENDOR_AIRONET, PCMCIA_PRODUCT_AIRONET_PC4800,
99 PCMCIA_CIS_AIRONET_PC4800, PCMCIA_STR_AIRONET_PC4800 },
100 { PCMCIA_VENDOR_AIRONET, PCMCIA_PRODUCT_AIRONET_PC4500,
101 PCMCIA_CIS_AIRONET_PC4500, PCMCIA_STR_AIRONET_PC4500 },
102 { PCMCIA_VENDOR_AIRONET, PCMCIA_PRODUCT_AIRONET_350,
103 PCMCIA_CIS_AIRONET_350, PCMCIA_STR_AIRONET_350 },
104 { 0, 0,
105 { NULL, NULL, NULL, NULL }, NULL }
106 };
107
108 static int
109 an_pcmcia_enable(sc)
110 struct an_softc *sc;
111 {
112 struct an_pcmcia_softc *psc = (struct an_pcmcia_softc *)sc;
113 struct pcmcia_function *pf = psc->sc_pf;
114
115 /* establish the interrupt. */
116 psc->sc_ih = pcmcia_intr_establish(pf, IPL_NET, an_intr, sc);
117 if (psc->sc_ih == NULL) {
118 printf("%s: couldn't establish interrupt\n",
119 sc->sc_dev.dv_xname);
120 return (1);
121 }
122
123 if (pcmcia_function_enable(pf)) {
124 pcmcia_intr_disestablish(pf, psc->sc_ih);
125 return (1);
126 }
127 DELAY(1000);
128
129 return (0);
130 }
131
132 static void
133 an_pcmcia_disable(sc)
134 struct an_softc *sc;
135 {
136 struct an_pcmcia_softc *psc = (struct an_pcmcia_softc *)sc;
137 struct pcmcia_function *pf = psc->sc_pf;
138
139 pcmcia_function_disable(pf);
140 pcmcia_intr_disestablish(pf, psc->sc_ih);
141 }
142
143 static int
144 an_pcmcia_match(parent, match, aux)
145 struct device *parent;
146 struct cfdata *match;
147 void *aux;
148 {
149 struct pcmcia_attach_args *pa = aux;
150 struct an_pcmcia_product *app;
151
152 for (app = an_pcmcia_products; app->app_name != NULL; app++) {
153 /* match by vendor/product id */
154 if (pa->manufacturer != PCMCIA_VENDOR_INVALID &&
155 pa->manufacturer == app->app_vendor &&
156 pa->product != PCMCIA_PRODUCT_INVALID &&
157 pa->product == app->app_product)
158 return 1;
159
160 /* match by CIS information */
161 if (pa->card->cis1_info[0] != NULL &&
162 app->app_cisinfo[0] != NULL &&
163 strcmp(pa->card->cis1_info[0], app->app_cisinfo[0]) == 0 &&
164 pa->card->cis1_info[1] != NULL &&
165 app->app_cisinfo[1] != NULL &&
166 strcmp(pa->card->cis1_info[1], app->app_cisinfo[1]) == 0)
167 return 1;
168 }
169 return 0;
170 }
171
172 static void
173 an_pcmcia_attach(parent, self, aux)
174 struct device *parent, *self;
175 void *aux;
176 {
177 struct an_pcmcia_softc *psc = (void *)self;
178 struct an_softc *sc = &psc->sc_an;
179 struct pcmcia_attach_args *pa = aux;
180 struct pcmcia_config_entry *cfe;
181 char devinfo[256];
182
183 /* Print out what we are. */
184 pcmcia_devinfo(&pa->pf->sc->card, 0, devinfo, sizeof(devinfo));
185 printf(": %s\n", devinfo);
186
187 psc->sc_pf = pa->pf;
188 if ((cfe = SIMPLEQ_FIRST(&pa->pf->cfe_head)) == NULL) {
189 printf("%s: no suitable CIS info found\n", sc->sc_dev.dv_xname);
190 goto fail1;
191 }
192
193 if (pcmcia_io_alloc(psc->sc_pf, cfe->iospace[0].start,
194 cfe->iospace[0].length, AN_IOSIZ, &psc->sc_pcioh) != 0) {
195 printf("%s: failed to allocate io space\n",
196 sc->sc_dev.dv_xname);
197 goto fail1;
198 }
199
200 if (pcmcia_io_map(psc->sc_pf, PCMCIA_WIDTH_AUTO, 0, psc->sc_pcioh.size,
201 &psc->sc_pcioh, &psc->sc_io_window) != 0) {
202 printf("%s: failed to map io space\n", sc->sc_dev.dv_xname);
203 goto fail2;
204 }
205
206 pcmcia_function_init(psc->sc_pf, cfe);
207
208 if (pcmcia_function_enable(psc->sc_pf)) {
209 printf("%s: failed to enable pcmcia\n", sc->sc_dev.dv_xname);
210 goto fail3;
211 }
212
213 if ((psc->sc_ih = pcmcia_intr_establish(psc->sc_pf, IPL_NET, an_intr,
214 sc)) == NULL) {
215 printf("%s: unable to establish interrupt\n",
216 sc->sc_dev.dv_xname);
217 goto fail4;
218 }
219
220 sc->sc_iot = psc->sc_pcioh.iot;
221 sc->sc_ioh = psc->sc_pcioh.ioh;
222 sc->sc_enabled = 1;
223 sc->sc_enable = an_pcmcia_enable;
224 sc->sc_disable = an_pcmcia_disable;
225
226 if (an_attach(sc) != 0) {
227 printf("%s: failed to attach controller\n",
228 sc->sc_dev.dv_xname);
229 goto fail5;
230 }
231 psc->sc_powerhook = powerhook_establish(an_power, sc);
232 sc->sc_enabled = 0;
233
234 /* disable device and disestablish the interrupt */
235 an_pcmcia_disable(sc);
236 return;
237
238 fail5:
239 pcmcia_intr_disestablish(psc->sc_pf, psc->sc_ih);
240 fail4:
241 pcmcia_function_disable(psc->sc_pf);
242 fail3:
243 pcmcia_io_unmap(psc->sc_pf, psc->sc_io_window);
244 fail2:
245 pcmcia_io_free(psc->sc_pf, &psc->sc_pcioh);
246 fail1:
247 psc->sc_io_window = -1;
248 }
249
250
251 static int
252 an_pcmcia_detach(self, flags)
253 struct device *self;
254 int flags;
255 {
256 struct an_pcmcia_softc *psc = (struct an_pcmcia_softc *)self;
257 int error;
258
259 if (psc->sc_io_window == -1)
260 /* Nothing to detach. */
261 return (0);
262
263 if (psc->sc_powerhook != NULL)
264 powerhook_disestablish(psc->sc_powerhook);
265
266 error = an_detach(&psc->sc_an);
267 if (error != 0)
268 return (error);
269
270 /* Unmap our i/o window. */
271 pcmcia_io_unmap(psc->sc_pf, psc->sc_io_window);
272
273 /* Free our i/o space. */
274 pcmcia_io_free(psc->sc_pf, &psc->sc_pcioh);
275 return (0);
276 }
Cache object: 6486f053f21859b3484cca5a73f10cb0
|