FreeBSD/Linux Kernel Cross Reference
sys/pci/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 <net/ethernet.h>
46 #include <net/if_arp.h>
47 #include <pci/pcivar.h>
48 #include <dev/pdq/pdqvar.h>
49 #include <dev/pdq/pdqreg.h>
50 #elif defined(__bsdi__)
51 #include <i386/isa/isavar.h>
52 #include <i386/isa/icu.h>
53 #ifndef DRQNONE
54 #define DRQNONE 0
55 #endif
56 #if _BSDI_VERSION < 199401
57 #define IRQSHARE 0
58 #endif
59 #elif defined(__NetBSD__)
60 #include <dev/pci/pcivar.h>
61 #include <dev/ic/pdqvar.h>
62 #include <dev/ic/pdqreg.h>
63 #endif /* __NetBSD__ */
64
65
66 #define DEC_VENDORID 0x1011
67 #define DEFPA_CHIPID 0x000F
68 #define PCI_VENDORID(x) ((x) & 0xFFFF)
69 #define PCI_CHIPID(x) (((x) >> 16) & 0xFFFF)
70
71 #define DEFPA_LATENCY 0x88
72
73 #define PCI_CFLT 0x0C /* Configuration Latency */
74 #define PCI_CBMA 0x10 /* Configuration Base Memory Address */
75 #define PCI_CBIO 0x14 /* Configuration Base I/O Address */
76
77 #if defined(__FreeBSD__)
78 #if NFPA < 4
79 #undef NFPA
80 #define NFPA 4
81 #endif
82 static pdq_softc_t *pdqs_pci[NFPA];
83 #define PDQ_PCI_UNIT_TO_SOFTC(unit) (pdqs_pci[unit])
84 #if BSD >= 199506
85 #define pdq_pci_ifwatchdog NULL
86 #endif
87
88 #elif defined(__bsdi__)
89 extern struct cfdriver fpacd;
90 #define PDQ_PCI_UNIT_TO_SOFTC(unit) ((pdq_softc_t *)fpacd.cd_devs[unit])
91
92 #elif defined(__NetBSD__)
93 extern struct cfattach fpa_ca;
94 extern struct cfdriver fpa_cd;
95 #define PDQ_PCI_UNIT_TO_SOFTC(unit) ((pdq_softc_t *)fpa_cd.cd_devs[unit])
96 #define pdq_pci_ifwatchdog NULL
97 #endif
98
99 #ifndef pdq_pci_ifwatchdog
100 static ifnet_ret_t
101 pdq_pci_ifwatchdog(
102 int unit)
103 {
104 pdq_ifwatchdog(&PDQ_PCI_UNIT_TO_SOFTC(unit)->sc_if);
105 }
106 #endif
107
108 #if defined(__FreeBSD__) && BSD >= 199506
109 static void
110 pdq_pci_ifintr(
111 void *arg)
112 {
113 (void) pdq_interrupt(((pdq_softc_t *) arg)->sc_pdq);
114 }
115 #else
116 static int
117 pdq_pci_ifintr(
118 void *arg)
119 {
120 pdq_softc_t * const sc = (pdq_softc_t *) arg;
121 #ifdef __FreeBSD__
122 return pdq_interrupt(sc->sc_pdq);
123 #elif defined(__bsdi__) || defined(__NetBSD__)
124 (void) pdq_interrupt(sc->sc_pdq);
125 return 1;
126 #endif
127 }
128 #endif /* __FreeBSD && BSD */
129
130 #if defined(__FreeBSD__)
131 static void pdq_pci_shutdown(int, void *);
132
133 /*
134 * This is the PCI configuration support. Since the PDQ is available
135 * on both EISA and PCI boards, one must be careful in how defines the
136 * PDQ in the config file.
137 */
138 static const char *
139 pdq_pci_probe(
140 pcici_t config_id,
141 pcidi_t device_id)
142 {
143 if (PCI_VENDORID(device_id) == DEC_VENDORID &&
144 PCI_CHIPID(device_id) == DEFPA_CHIPID)
145 return "Digital DEFPA PCI FDDI Controller";
146 return NULL;
147 }
148
149 static void
150 pdq_pci_attach(
151 pcici_t config_id,
152 int unit)
153 {
154 pdq_softc_t *sc;
155 vm_offset_t va_csrs, pa_csrs;
156 pdq_uint32_t data;
157
158 if (unit == NFPA) {
159 printf("fpa%d: not configured; kernel is built for only %d device%s.\n",
160 unit, NFPA, NFPA == 1 ? "" : "s");
161 return;
162 }
163
164 data = pci_conf_read(config_id, PCI_CFLT);
165 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
166 data &= ~0xFF00;
167 data |= DEFPA_LATENCY << 8;
168 pci_conf_write(config_id, PCI_CFLT, data);
169 }
170
171 sc = (pdq_softc_t *) malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
172 if (sc == NULL)
173 return;
174
175 bzero(sc, sizeof(pdq_softc_t)); /* Zero out the softc*/
176 if (!pci_map_mem(config_id, PCI_CBMA, &va_csrs, &pa_csrs)) {
177 free((void *) sc, M_DEVBUF);
178 return;
179 }
180
181 sc->sc_if.if_name = "fpa";
182 sc->sc_if.if_unit = unit;
183 sc->sc_membase = (pdq_bus_memaddr_t) va_csrs;
184 sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
185 sc->sc_if.if_name, sc->sc_if.if_unit,
186 (void *) sc, PDQ_DEFPA);
187 if (sc->sc_pdq == NULL) {
188 free((void *) sc, M_DEVBUF);
189 return;
190 }
191 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
192 pdqs_pci[unit] = sc;
193 pdq_ifattach(sc, pdq_pci_ifwatchdog);
194 pci_map_int(config_id, pdq_pci_ifintr, (void*) sc, &net_imask);
195 at_shutdown(pdq_pci_shutdown, (void *) sc, SHUTDOWN_POST_SYNC);
196
197 }
198
199 static void
200 pdq_pci_shutdown(
201 int howto,
202 void *sc)
203 {
204 pdq_hwreset(((pdq_softc_t *)sc)->sc_pdq);
205 }
206
207 static u_long pdq_pci_count;
208
209 static struct pci_device fpadevice = {
210 "fpa",
211 pdq_pci_probe,
212 pdq_pci_attach,
213 &pdq_pci_count,
214 NULL
215 };
216
217 #ifdef DATA_SET
218 DATA_SET (pcidevice_set, fpadevice);
219 #endif
220 #elif defined(__bsdi__)
221
222 static int
223 pdq_pci_match(
224 pci_devaddr_t *pa)
225 {
226 int irq;
227 int id;
228
229 id = pci_inl(pa, PCI_VENDOR_ID);
230 if (PCI_VENDORID(id) != DEC_VENDORID || PCI_CHIPID(id) != DEFPA_CHIPID)
231 return 0;
232
233 irq = pci_inl(pa, PCI_I_LINE) & 0xFF;
234 if (irq == 0 || irq >= 16)
235 return 0;
236
237 return 1;
238 }
239
240 int
241 pdq_pci_probe(
242 struct device *parent,
243 struct cfdata *cf,
244 void *aux)
245 {
246 struct isa_attach_args *ia = (struct isa_attach_args *) aux;
247 pdq_uint32_t irq, data;
248 pci_devaddr_t *pa;
249
250 pa = pci_scan(pdq_pci_match);
251 if (pa == NULL)
252 return 0;
253
254 irq = (1 << (pci_inl(pa, PCI_I_LINE) & 0xFF));
255
256 if (ia->ia_irq != IRQUNK && irq != ia->ia_irq) {
257 printf("fpa%d: error: desired IRQ of %d does not match device's actual IRQ of %d\n",
258 cf->cf_unit,
259 ffs(ia->ia_irq) - 1, ffs(irq) - 1);
260 return 0;
261 }
262 if (ia->ia_irq == IRQUNK) {
263 (void) isa_irqalloc(irq);
264 ia->ia_irq = irq;
265 }
266
267 /* PCI bus masters don't use host DMA channels */
268 ia->ia_drq = DRQNONE;
269
270 /* Get the memory base address; assume the BIOS set it up correctly */
271 ia->ia_maddr = (caddr_t) (pci_inl(pa, PCI_CBMA) & ~7);
272 pci_outl(pa, PCI_CBMA, 0xFFFFFFFF);
273 ia->ia_msize = ((~pci_inl(pa, PCI_CBMA)) | 7) + 1;
274 pci_outl(pa, PCI_CBMA, (int) ia->ia_maddr);
275
276 /* Disable I/O space access */
277 pci_outl(pa, PCI_COMMAND, pci_inl(pa, PCI_COMMAND) & ~1);
278 ia->ia_iobase = 0;
279 ia->ia_iosize = 0;
280
281 /* Make sure the latency timer is what the DEFPA likes */
282 data = pci_inl(pa, PCI_CFLT);
283 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
284 data &= ~0xFF00;
285 data |= DEFPA_LATENCY << 8;
286 pci_outl(pa, PCI_CFLT, data);
287 }
288 ia->ia_irq |= IRQSHARE;
289
290 return 1;
291 }
292
293 void
294 pdq_pci_attach(
295 struct device *parent,
296 struct device *self,
297 void *aux)
298 {
299 pdq_softc_t *sc = (pdq_softc_t *) self;
300 register struct isa_attach_args *ia = (struct isa_attach_args *) aux;
301 register struct ifnet *ifp = &sc->sc_if;
302 int i;
303
304 sc->sc_if.if_unit = sc->sc_dev.dv_unit;
305 sc->sc_if.if_name = "fpa";
306 sc->sc_if.if_flags = 0;
307 sc->sc_membase = (pdq_bus_memaddr_t) mapphys((vm_offset_t)ia->ia_maddr, ia->ia_msize);
308
309 sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
310 sc->sc_if.if_name, sc->sc_if.if_unit,
311 (void *) sc, PDQ_DEFPA);
312 if (sc->sc_pdq == NULL) {
313 printf("fpa%d: initialization failed\n", sc->sc_if.if_unit);
314 return;
315 }
316
317 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
318
319 pdq_ifattach(sc, pdq_pci_ifwatchdog);
320
321 isa_establish(&sc->sc_id, &sc->sc_dev);
322
323 sc->sc_ih.ih_fun = pdq_pci_ifintr;
324 sc->sc_ih.ih_arg = (void *)sc;
325 intr_establish(ia->ia_irq, &sc->sc_ih, DV_NET);
326
327 sc->sc_ats.func = (void (*)(void *)) pdq_hwreset;
328 sc->sc_ats.arg = (void *) sc->sc_pdq;
329 atshutdown(&sc->sc_ats, ATSH_ADD);
330 }
331
332 struct cfdriver fpacd = {
333 0, "fpa", pdq_pci_probe, pdq_pci_attach,
334 #if _BSDI_VERSION >= 199401
335 DV_IFNET,
336 #endif
337 sizeof(pdq_softc_t)
338 };
339
340 #elif defined(__NetBSD__)
341
342 static int
343 pdq_pci_match(
344 struct device *parent,
345 void *match,
346 void *aux)
347 {
348 struct pci_attach_args *pa = (struct pci_attach_args *) aux;
349
350 if (PCI_VENDORID(pa->pa_id) != DEC_VENDORID)
351 return 0;
352 if (PCI_CHIPID(pa->pa_id) == DEFPA_CHIPID)
353 return 1;
354
355 return 0;
356 }
357
358 static void
359 pdq_pci_attach(
360 struct device * const parent,
361 struct device * const self,
362 void * const aux)
363 {
364 pdq_softc_t * const sc = (pdq_softc_t *) self;
365 struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
366 pdq_uint32_t data;
367 pci_intr_handle_t intrhandle;
368 const char *intrstr;
369 #ifdef PDQ_IOMAPPED
370 bus_io_addr_t iobase;
371 bus_io_size_t iosize;
372 #else
373 bus_mem_addr_t membase;
374 bus_mem_size_t memsize;
375 #endif
376
377 data = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFLT);
378 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
379 data &= ~0xFF00;
380 data |= DEFPA_LATENCY << 8;
381 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_CFLT, data);
382 }
383
384 sc->sc_bc = pa->pa_bc;
385 bcopy(sc->sc_dev.dv_xname, sc->sc_if.if_xname, IFNAMSIZ);
386 sc->sc_if.if_flags = 0;
387 sc->sc_if.if_softc = sc;
388
389 #ifdef PDQ_IOMAPPED
390 if (pci_io_find(pa->pa_pc, pa->pa_tag, PCI_CBIO, &iobase, &iosize)
391 || bus_io_map(pa->pa_bc, iobase, iosize, &sc->sc_iobase))
392 return;
393 #else
394 if (pci_mem_find(pa->pa_pc, pa->pa_tag, PCI_CBMA, &membase, &memsize, NULL)
395 || bus_mem_map(pa->pa_bc, membase, memsize, 0, &sc->sc_membase))
396 return;
397 #endif
398
399 sc->sc_pdq = pdq_initialize(sc->sc_bc, sc->sc_membase,
400 sc->sc_if.if_xname, 0,
401 (void *) sc, PDQ_DEFPA);
402 if (sc->sc_pdq == NULL) {
403 printf("%s: initialization failed\n", sc->sc_dev.dv_xname);
404 return;
405 }
406
407 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
408 pdq_ifattach(sc, pdq_pci_ifwatchdog);
409
410 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
411 pa->pa_intrline, &intrhandle)) {
412 printf("%s: couldn't map interrupt\n", self->dv_xname);
413 return;
414 }
415 intrstr = pci_intr_string(pa->pa_pc, intrhandle);
416 sc->sc_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET, pdq_pci_ifintr, sc);
417 if (sc->sc_ih == NULL) {
418 printf("%s: couldn't establish interrupt", self->dv_xname);
419 if (intrstr != NULL)
420 printf(" at %s", intrstr);
421 printf("\n");
422 return;
423 }
424
425 sc->sc_ats = shutdownhook_establish((void (*)(void *)) pdq_hwreset, sc->sc_pdq);
426 if (sc->sc_ats == NULL)
427 printf("%s: warning: couldn't establish shutdown hook\n", self->dv_xname);
428 if (intrstr != NULL)
429 printf("%s: interrupting at %s\n", self->dv_xname, intrstr);
430 }
431
432 struct cfattach fpa_ca = {
433 sizeof(pdq_softc_t), pdq_pci_match, pdq_pci_attach
434 };
435
436 struct cfdriver fpa_cd = {
437 0, "fpa", DV_IFNET
438 };
439
440 #endif /* __NetBSD__ */
Cache object: 01d46e6baac87ef51c2ff1afd9c6e0c6
|