FreeBSD/Linux Kernel Cross Reference
sys/dev/pdq/if_fpa.c
1 /*-
2 * Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. The name of the author may not be used to endorse or promote products
11 * derived from this software withough specific prior written permission
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 *
24 * $FreeBSD$
25 *
26 */
27
28 /*
29 * DEC PDQ FDDI Controller; code for BSD derived operating systems
30 *
31 * This module supports the DEC DEFPA PCI FDDI Controller
32 */
33
34 #include <sys/param.h>
35 #include <sys/kernel.h>
36 #include <sys/socket.h>
37 #if defined(__bsdi__) || defined(__NetBSD__)
38 #include <sys/device.h>
39 #endif
40
41 #include <net/if.h>
42
43 #if defined(__FreeBSD__)
44 #include "fpa.h"
45 #include <sys/eventhandler.h>
46 #include <net/ethernet.h>
47 #include <net/if_arp.h>
48 #include <pci/pcivar.h>
49 #include <dev/pdq/pdqvar.h>
50 #include <dev/pdq/pdqreg.h>
51 #elif defined(__bsdi__)
52 #include <i386/isa/isavar.h>
53 #include <i386/isa/icu.h>
54 #ifndef DRQNONE
55 #define DRQNONE 0
56 #endif
57 #if _BSDI_VERSION < 199401
58 #define IRQSHARE 0
59 #endif
60 #elif defined(__NetBSD__)
61 #include <dev/pci/pcivar.h>
62 #include <dev/ic/pdqvar.h>
63 #include <dev/ic/pdqreg.h>
64 #endif /* __NetBSD__ */
65
66
67 #define DEC_VENDORID 0x1011
68 #define DEFPA_CHIPID 0x000F
69 #define PCI_VENDORID(x) ((x) & 0xFFFF)
70 #define PCI_CHIPID(x) (((x) >> 16) & 0xFFFF)
71
72 #define DEFPA_LATENCY 0x88
73
74 #define PCI_CFLT 0x0C /* Configuration Latency */
75 #define PCI_CBMA 0x10 /* Configuration Base Memory Address */
76 #define PCI_CBIO 0x14 /* Configuration Base I/O Address */
77
78 #if defined(__FreeBSD__)
79 #if NFPA < 4
80 #undef NFPA
81 #define NFPA 4
82 #endif
83 static pdq_softc_t *pdqs_pci[NFPA];
84 #define PDQ_PCI_UNIT_TO_SOFTC(unit) (pdqs_pci[unit])
85 #if BSD >= 199506
86 #define pdq_pci_ifwatchdog NULL
87 #endif
88
89 #elif defined(__bsdi__)
90 extern struct cfdriver fpacd;
91 #define PDQ_PCI_UNIT_TO_SOFTC(unit) ((pdq_softc_t *)fpacd.cd_devs[unit])
92
93 #elif defined(__NetBSD__)
94 extern struct cfattach fpa_ca;
95 extern struct cfdriver fpa_cd;
96 #define PDQ_PCI_UNIT_TO_SOFTC(unit) ((pdq_softc_t *)fpa_cd.cd_devs[unit])
97 #define pdq_pci_ifwatchdog NULL
98 #endif
99
100 #ifndef pdq_pci_ifwatchdog
101 static ifnet_ret_t
102 pdq_pci_ifwatchdog(
103 int unit)
104 {
105 pdq_ifwatchdog(&PDQ_PCI_UNIT_TO_SOFTC(unit)->sc_if);
106 }
107 #endif
108
109 #if defined(__FreeBSD__) && BSD >= 199506
110 static void
111 pdq_pci_ifintr(
112 void *arg)
113 {
114 (void) pdq_interrupt(((pdq_softc_t *) arg)->sc_pdq);
115 }
116 #else
117 static int
118 pdq_pci_ifintr(
119 void *arg)
120 {
121 pdq_softc_t * const sc = (pdq_softc_t *) arg;
122 #ifdef __FreeBSD__
123 return pdq_interrupt(sc->sc_pdq);
124 #elif defined(__bsdi__) || defined(__NetBSD__)
125 (void) pdq_interrupt(sc->sc_pdq);
126 return 1;
127 #endif
128 }
129 #endif /* __FreeBSD && BSD */
130
131 #if defined(__FreeBSD__)
132 static void pdq_pci_shutdown(void *, int);
133
134 /*
135 * This is the PCI configuration support. Since the PDQ is available
136 * on both EISA and PCI boards, one must be careful in how defines the
137 * PDQ in the config file.
138 */
139 static const char *
140 pdq_pci_probe(
141 pcici_t config_id,
142 pcidi_t device_id)
143 {
144 if (PCI_VENDORID(device_id) == DEC_VENDORID &&
145 PCI_CHIPID(device_id) == DEFPA_CHIPID)
146 return "Digital DEFPA PCI FDDI Controller";
147 return NULL;
148 }
149
150 static void
151 pdq_pci_attach(
152 pcici_t config_id,
153 int unit)
154 {
155 pdq_softc_t *sc;
156 vm_offset_t va_csrs, pa_csrs;
157 pdq_uint32_t data;
158
159 if (unit == NFPA) {
160 printf("fpa%d: not configured; kernel is built for only %d device%s.\n",
161 unit, NFPA, NFPA == 1 ? "" : "s");
162 return;
163 }
164
165 data = pci_conf_read(config_id, PCI_CFLT);
166 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
167 data &= ~0xFF00;
168 data |= DEFPA_LATENCY << 8;
169 pci_conf_write(config_id, PCI_CFLT, data);
170 }
171
172 sc = (pdq_softc_t *) malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
173 if (sc == NULL)
174 return;
175
176 bzero(sc, sizeof(pdq_softc_t)); /* Zero out the softc*/
177 if (!pci_map_mem(config_id, PCI_CBMA, &va_csrs, &pa_csrs)) {
178 free((void *) sc, M_DEVBUF);
179 return;
180 }
181
182 sc->sc_if.if_name = "fpa";
183 sc->sc_if.if_unit = unit;
184 sc->sc_membase = (pdq_bus_memaddr_t) va_csrs;
185 sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
186 sc->sc_if.if_name, sc->sc_if.if_unit,
187 (void *) sc, PDQ_DEFPA);
188 if (sc->sc_pdq == NULL) {
189 free((void *) sc, M_DEVBUF);
190 return;
191 }
192 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
193 pdqs_pci[unit] = sc;
194 pdq_ifattach(sc, pdq_pci_ifwatchdog);
195 pci_map_int(config_id, pdq_pci_ifintr, (void*) sc, &net_imask);
196 EVENTHANDLER_REGISTER(shutdown_post_sync, pdq_pci_shutdown, sc,
197 SHUTDOWN_PRI_DEFAULT);
198
199 }
200
201 static void
202 pdq_pci_shutdown(
203 void *sc,
204 int howto)
205 {
206 pdq_hwreset(((pdq_softc_t *)sc)->sc_pdq);
207 }
208
209 static u_long pdq_pci_count;
210
211 static struct pci_device fpadevice = {
212 "fpa",
213 pdq_pci_probe,
214 pdq_pci_attach,
215 &pdq_pci_count,
216 NULL
217 };
218
219 COMPAT_PCI_DRIVER (fpa, fpadevice);
220
221 #elif defined(__bsdi__)
222
223 static int
224 pdq_pci_match(
225 pci_devaddr_t *pa)
226 {
227 int irq;
228 int id;
229
230 id = pci_inl(pa, PCI_VENDOR_ID);
231 if (PCI_VENDORID(id) != DEC_VENDORID || PCI_CHIPID(id) != DEFPA_CHIPID)
232 return 0;
233
234 irq = pci_inl(pa, PCI_I_LINE) & 0xFF;
235 if (irq == 0 || irq >= 16)
236 return 0;
237
238 return 1;
239 }
240
241 int
242 pdq_pci_probe(
243 struct device *parent,
244 struct cfdata *cf,
245 void *aux)
246 {
247 struct isa_attach_args *ia = (struct isa_attach_args *) aux;
248 pdq_uint32_t irq, data;
249 pci_devaddr_t *pa;
250
251 pa = pci_scan(pdq_pci_match);
252 if (pa == NULL)
253 return 0;
254
255 irq = (1 << (pci_inl(pa, PCI_I_LINE) & 0xFF));
256
257 if (ia->ia_irq != IRQUNK && irq != ia->ia_irq) {
258 printf("fpa%d: error: desired IRQ of %d does not match device's actual IRQ of %d\n",
259 cf->cf_unit,
260 ffs(ia->ia_irq) - 1, ffs(irq) - 1);
261 return 0;
262 }
263 if (ia->ia_irq == IRQUNK) {
264 (void) isa_irqalloc(irq);
265 ia->ia_irq = irq;
266 }
267
268 /* PCI bus masters don't use host DMA channels */
269 ia->ia_drq = DRQNONE;
270
271 /* Get the memory base address; assume the BIOS set it up correctly */
272 ia->ia_maddr = (caddr_t) (pci_inl(pa, PCI_CBMA) & ~7);
273 pci_outl(pa, PCI_CBMA, 0xFFFFFFFF);
274 ia->ia_msize = ((~pci_inl(pa, PCI_CBMA)) | 7) + 1;
275 pci_outl(pa, PCI_CBMA, (int) ia->ia_maddr);
276
277 /* Disable I/O space access */
278 pci_outl(pa, PCI_COMMAND, pci_inl(pa, PCI_COMMAND) & ~1);
279 ia->ia_iobase = 0;
280 ia->ia_iosize = 0;
281
282 /* Make sure the latency timer is what the DEFPA likes */
283 data = pci_inl(pa, PCI_CFLT);
284 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
285 data &= ~0xFF00;
286 data |= DEFPA_LATENCY << 8;
287 pci_outl(pa, PCI_CFLT, data);
288 }
289 ia->ia_irq |= IRQSHARE;
290
291 return 1;
292 }
293
294 void
295 pdq_pci_attach(
296 struct device *parent,
297 struct device *self,
298 void *aux)
299 {
300 pdq_softc_t *sc = (pdq_softc_t *) self;
301 register struct isa_attach_args *ia = (struct isa_attach_args *) aux;
302 register struct ifnet *ifp = &sc->sc_if;
303 int i;
304
305 sc->sc_if.if_unit = sc->sc_dev.dv_unit;
306 sc->sc_if.if_name = "fpa";
307 sc->sc_if.if_flags = 0;
308 sc->sc_membase = (pdq_bus_memaddr_t) mapphys((vm_offset_t)ia->ia_maddr, ia->ia_msize);
309
310 sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
311 sc->sc_if.if_name, sc->sc_if.if_unit,
312 (void *) sc, PDQ_DEFPA);
313 if (sc->sc_pdq == NULL) {
314 printf("fpa%d: initialization failed\n", sc->sc_if.if_unit);
315 return;
316 }
317
318 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
319
320 pdq_ifattach(sc, pdq_pci_ifwatchdog);
321
322 isa_establish(&sc->sc_id, &sc->sc_dev);
323
324 sc->sc_ih.ih_fun = pdq_pci_ifintr;
325 sc->sc_ih.ih_arg = (void *)sc;
326 intr_establish(ia->ia_irq, &sc->sc_ih, DV_NET);
327
328 sc->sc_ats.func = (void (*)(void *)) pdq_hwreset;
329 sc->sc_ats.arg = (void *) sc->sc_pdq;
330 atshutdown(&sc->sc_ats, ATSH_ADD);
331 }
332
333 struct cfdriver fpacd = {
334 0, "fpa", pdq_pci_probe, pdq_pci_attach,
335 #if _BSDI_VERSION >= 199401
336 DV_IFNET,
337 #endif
338 sizeof(pdq_softc_t)
339 };
340
341 #elif defined(__NetBSD__)
342
343 static int
344 pdq_pci_match(
345 struct device *parent,
346 void *match,
347 void *aux)
348 {
349 struct pci_attach_args *pa = (struct pci_attach_args *) aux;
350
351 if (PCI_VENDORID(pa->pa_id) != DEC_VENDORID)
352 return 0;
353 if (PCI_CHIPID(pa->pa_id) == DEFPA_CHIPID)
354 return 1;
355
356 return 0;
357 }
358
359 static void
360 pdq_pci_attach(
361 struct device * const parent,
362 struct device * const self,
363 void * const aux)
364 {
365 pdq_softc_t * const sc = (pdq_softc_t *) self;
366 struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
367 pdq_uint32_t data;
368 pci_intr_handle_t intrhandle;
369 const char *intrstr;
370 #ifdef PDQ_IOMAPPED
371 bus_io_addr_t iobase;
372 bus_io_size_t iosize;
373 #else
374 bus_mem_addr_t membase;
375 bus_mem_size_t memsize;
376 #endif
377
378 data = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFLT);
379 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
380 data &= ~0xFF00;
381 data |= DEFPA_LATENCY << 8;
382 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_CFLT, data);
383 }
384
385 sc->sc_bc = pa->pa_bc;
386 bcopy(sc->sc_dev.dv_xname, sc->sc_if.if_xname, IFNAMSIZ);
387 sc->sc_if.if_flags = 0;
388 sc->sc_if.if_softc = sc;
389
390 #ifdef PDQ_IOMAPPED
391 if (pci_io_find(pa->pa_pc, pa->pa_tag, PCI_CBIO, &iobase, &iosize)
392 || bus_io_map(pa->pa_bc, iobase, iosize, &sc->sc_iobase))
393 return;
394 #else
395 if (pci_mem_find(pa->pa_pc, pa->pa_tag, PCI_CBMA, &membase, &memsize, NULL)
396 || bus_mem_map(pa->pa_bc, membase, memsize, 0, &sc->sc_membase))
397 return;
398 #endif
399
400 sc->sc_pdq = pdq_initialize(sc->sc_bc, sc->sc_membase,
401 sc->sc_if.if_xname, 0,
402 (void *) sc, PDQ_DEFPA);
403 if (sc->sc_pdq == NULL) {
404 printf("%s: initialization failed\n", sc->sc_dev.dv_xname);
405 return;
406 }
407
408 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
409 pdq_ifattach(sc, pdq_pci_ifwatchdog);
410
411 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
412 pa->pa_intrline, &intrhandle)) {
413 printf("%s: couldn't map interrupt\n", self->dv_xname);
414 return;
415 }
416 intrstr = pci_intr_string(pa->pa_pc, intrhandle);
417 sc->sc_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET, pdq_pci_ifintr, sc);
418 if (sc->sc_ih == NULL) {
419 printf("%s: couldn't establish interrupt", self->dv_xname);
420 if (intrstr != NULL)
421 printf(" at %s", intrstr);
422 printf("\n");
423 return;
424 }
425
426 sc->sc_ats = shutdownhook_establish((void (*)(void *)) pdq_hwreset, sc->sc_pdq);
427 if (sc->sc_ats == NULL)
428 printf("%s: warning: couldn't establish shutdown hook\n", self->dv_xname);
429 if (intrstr != NULL)
430 printf("%s: interrupting at %s\n", self->dv_xname, intrstr);
431 }
432
433 struct cfattach fpa_ca = {
434 sizeof(pdq_softc_t), pdq_pci_match, pdq_pci_attach
435 };
436
437 struct cfdriver fpa_cd = {
438 0, "fpa", DV_IFNET
439 };
440
441 #endif /* __NetBSD__ */
Cache object: ca06e06434ca424879af45673fae09f1
|