Remove all remaining SPL code. Replace the mtd_cpl field in the machine
[dragonfly.git] / sys / dev / netif / fpa / if_fpa.c
CommitLineData
984263bc
MD
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: src/sys/dev/pdq/if_fpa.c,v 1.13 1999/08/28 00:50:50 peter Exp $
38787eef 25 * $DragonFly: src/sys/dev/netif/fpa/Attic/if_fpa.c,v 1.10 2005/06/16 21:12:34 dillon Exp $
984263bc
MD
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
929783d0 43#if defined(__DragonFly__) || defined(__FreeBSD__)
1f2de5d4 44#include "use_fpa.h"
984263bc
MD
45#include <sys/eventhandler.h>
46#include <net/ethernet.h>
47#include <net/if_arp.h>
1f2de5d4
MD
48#include <bus/pci/pcivar.h>
49#include <dev/netif/pdq_layer/pdqvar.h>
50#include <dev/netif/pdq_layer/pdqreg.h>
984263bc
MD
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
929783d0 78#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
79#if NFPA < 4
80#undef NFPA
81#define NFPA 4
82#endif
83static 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__)
90extern struct cfdriver fpacd;
91#define PDQ_PCI_UNIT_TO_SOFTC(unit) ((pdq_softc_t *)fpacd.cd_devs[unit])
92
93#elif defined(__NetBSD__)
94extern struct cfattach fpa_ca;
95extern 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
101static ifnet_ret_t
102pdq_pci_ifwatchdog(
103 int unit)
104{
105 pdq_ifwatchdog(&PDQ_PCI_UNIT_TO_SOFTC(unit)->sc_if);
106}
107#endif
108
929783d0 109#if defined(__DragonFly__) || (defined(__FreeBSD__) && BSD >= 199506)
984263bc
MD
110static void
111pdq_pci_ifintr(
112 void *arg)
113{
114 (void) pdq_interrupt(((pdq_softc_t *) arg)->sc_pdq);
115}
116#else
117static int
118pdq_pci_ifintr(
119 void *arg)
120{
121 pdq_softc_t * const sc = (pdq_softc_t *) arg;
929783d0 122#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
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
929783d0 131#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
132static 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 */
139static const char *
140pdq_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
150static void
151pdq_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
c5541aee 172 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
984263bc
MD
173 if (!pci_map_mem(config_id, PCI_CBMA, &va_csrs, &pa_csrs)) {
174 free((void *) sc, M_DEVBUF);
175 return;
176 }
177
3e4a09e7 178 if_initname(&(sc->sc_if), "fpa", unit);
984263bc
MD
179 sc->sc_membase = (pdq_bus_memaddr_t) va_csrs;
180 sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
3e4a09e7 181 sc->sc_if.if_dname, sc->sc_if.if_dunit,
984263bc
MD
182 (void *) sc, PDQ_DEFPA);
183 if (sc->sc_pdq == NULL) {
184 free((void *) sc, M_DEVBUF);
185 return;
186 }
187 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
188 pdqs_pci[unit] = sc;
189 pdq_ifattach(sc, pdq_pci_ifwatchdog);
38787eef 190 pci_map_int(config_id, pdq_pci_ifintr, (void*) sc);
984263bc
MD
191 EVENTHANDLER_REGISTER(shutdown_post_sync, pdq_pci_shutdown, sc,
192 SHUTDOWN_PRI_DEFAULT);
193
194}
195
196static void
197pdq_pci_shutdown(
198 void *sc,
199 int howto)
200{
201 pdq_hwreset(((pdq_softc_t *)sc)->sc_pdq);
202}
203
204static u_long pdq_pci_count;
205
206static struct pci_device fpadevice = {
207 "fpa",
208 pdq_pci_probe,
209 pdq_pci_attach,
210 &pdq_pci_count,
211 NULL
212};
213
32832096 214COMPAT_PCI_DRIVER (if_fpa, fpadevice);
984263bc
MD
215
216#elif defined(__bsdi__)
217
218static int
219pdq_pci_match(
220 pci_devaddr_t *pa)
221{
222 int irq;
223 int id;
224
225 id = pci_inl(pa, PCI_VENDOR_ID);
226 if (PCI_VENDORID(id) != DEC_VENDORID || PCI_CHIPID(id) != DEFPA_CHIPID)
227 return 0;
228
229 irq = pci_inl(pa, PCI_I_LINE) & 0xFF;
230 if (irq == 0 || irq >= 16)
231 return 0;
232
233 return 1;
234}
235
236int
237pdq_pci_probe(
238 struct device *parent,
239 struct cfdata *cf,
240 void *aux)
241{
242 struct isa_attach_args *ia = (struct isa_attach_args *) aux;
243 pdq_uint32_t irq, data;
244 pci_devaddr_t *pa;
245
246 pa = pci_scan(pdq_pci_match);
247 if (pa == NULL)
248 return 0;
249
250 irq = (1 << (pci_inl(pa, PCI_I_LINE) & 0xFF));
251
252 if (ia->ia_irq != IRQUNK && irq != ia->ia_irq) {
253 printf("fpa%d: error: desired IRQ of %d does not match device's actual IRQ of %d\n",
254 cf->cf_unit,
255 ffs(ia->ia_irq) - 1, ffs(irq) - 1);
256 return 0;
257 }
258 if (ia->ia_irq == IRQUNK) {
259 (void) isa_irqalloc(irq);
260 ia->ia_irq = irq;
261 }
262
263 /* PCI bus masters don't use host DMA channels */
264 ia->ia_drq = DRQNONE;
265
266 /* Get the memory base address; assume the BIOS set it up correctly */
267 ia->ia_maddr = (caddr_t) (pci_inl(pa, PCI_CBMA) & ~7);
268 pci_outl(pa, PCI_CBMA, 0xFFFFFFFF);
269 ia->ia_msize = ((~pci_inl(pa, PCI_CBMA)) | 7) + 1;
270 pci_outl(pa, PCI_CBMA, (int) ia->ia_maddr);
271
272 /* Disable I/O space access */
273 pci_outl(pa, PCI_COMMAND, pci_inl(pa, PCI_COMMAND) & ~1);
274 ia->ia_iobase = 0;
275 ia->ia_iosize = 0;
276
277 /* Make sure the latency timer is what the DEFPA likes */
278 data = pci_inl(pa, PCI_CFLT);
279 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
280 data &= ~0xFF00;
281 data |= DEFPA_LATENCY << 8;
282 pci_outl(pa, PCI_CFLT, data);
283 }
284 ia->ia_irq |= IRQSHARE;
285
286 return 1;
287}
288
289void
290pdq_pci_attach(
291 struct device *parent,
292 struct device *self,
293 void *aux)
294{
295 pdq_softc_t *sc = (pdq_softc_t *) self;
f96d6c88
RG
296 struct isa_attach_args *ia = (struct isa_attach_args *) aux;
297 struct ifnet *ifp = &sc->sc_if;
984263bc
MD
298 int i;
299
3e4a09e7 300 if_initname(&(sc->sc_if), "fpa", sc->sc_dev.dv_unit);
984263bc
MD
301 sc->sc_if.if_flags = 0;
302 sc->sc_membase = (pdq_bus_memaddr_t) mapphys((vm_offset_t)ia->ia_maddr, ia->ia_msize);
303
304 sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
3e4a09e7 305 sc->sc_if.if_dname, sc->sc_if.if_dunit,
984263bc
MD
306 (void *) sc, PDQ_DEFPA);
307 if (sc->sc_pdq == NULL) {
3e4a09e7 308 printf("%s: initialization failed\n", sc->sc_if.if_xname);
984263bc
MD
309 return;
310 }
311
312 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
313
314 pdq_ifattach(sc, pdq_pci_ifwatchdog);
315
316 isa_establish(&sc->sc_id, &sc->sc_dev);
317
318 sc->sc_ih.ih_fun = pdq_pci_ifintr;
319 sc->sc_ih.ih_arg = (void *)sc;
320 intr_establish(ia->ia_irq, &sc->sc_ih, DV_NET);
321
322 sc->sc_ats.func = (void (*)(void *)) pdq_hwreset;
323 sc->sc_ats.arg = (void *) sc->sc_pdq;
324 atshutdown(&sc->sc_ats, ATSH_ADD);
325}
326
327struct cfdriver fpacd = {
328 0, "fpa", pdq_pci_probe, pdq_pci_attach,
329#if _BSDI_VERSION >= 199401
330 DV_IFNET,
331#endif
332 sizeof(pdq_softc_t)
333};
334
335#elif defined(__NetBSD__)
336
337static int
338pdq_pci_match(
339 struct device *parent,
340 void *match,
341 void *aux)
342{
343 struct pci_attach_args *pa = (struct pci_attach_args *) aux;
344
345 if (PCI_VENDORID(pa->pa_id) != DEC_VENDORID)
346 return 0;
347 if (PCI_CHIPID(pa->pa_id) == DEFPA_CHIPID)
348 return 1;
349
350 return 0;
351}
352
353static void
354pdq_pci_attach(
355 struct device * const parent,
356 struct device * const self,
357 void * const aux)
358{
359 pdq_softc_t * const sc = (pdq_softc_t *) self;
360 struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
361 pdq_uint32_t data;
362 pci_intr_handle_t intrhandle;
363 const char *intrstr;
364#ifdef PDQ_IOMAPPED
365 bus_io_addr_t iobase;
366 bus_io_size_t iosize;
367#else
368 bus_mem_addr_t membase;
369 bus_mem_size_t memsize;
370#endif
371
372 data = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFLT);
373 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
374 data &= ~0xFF00;
375 data |= DEFPA_LATENCY << 8;
376 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_CFLT, data);
377 }
378
379 sc->sc_bc = pa->pa_bc;
380 bcopy(sc->sc_dev.dv_xname, sc->sc_if.if_xname, IFNAMSIZ);
381 sc->sc_if.if_flags = 0;
382 sc->sc_if.if_softc = sc;
383
384#ifdef PDQ_IOMAPPED
385 if (pci_io_find(pa->pa_pc, pa->pa_tag, PCI_CBIO, &iobase, &iosize)
386 || bus_io_map(pa->pa_bc, iobase, iosize, &sc->sc_iobase))
387 return;
388#else
389 if (pci_mem_find(pa->pa_pc, pa->pa_tag, PCI_CBMA, &membase, &memsize, NULL)
390 || bus_mem_map(pa->pa_bc, membase, memsize, 0, &sc->sc_membase))
391 return;
392#endif
393
394 sc->sc_pdq = pdq_initialize(sc->sc_bc, sc->sc_membase,
395 sc->sc_if.if_xname, 0,
396 (void *) sc, PDQ_DEFPA);
397 if (sc->sc_pdq == NULL) {
398 printf("%s: initialization failed\n", sc->sc_dev.dv_xname);
399 return;
400 }
401
402 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
403 pdq_ifattach(sc, pdq_pci_ifwatchdog);
404
405 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
406 pa->pa_intrline, &intrhandle)) {
407 printf("%s: couldn't map interrupt\n", self->dv_xname);
408 return;
409 }
410 intrstr = pci_intr_string(pa->pa_pc, intrhandle);
411 sc->sc_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET, pdq_pci_ifintr, sc);
412 if (sc->sc_ih == NULL) {
413 printf("%s: couldn't establish interrupt", self->dv_xname);
414 if (intrstr != NULL)
415 printf(" at %s", intrstr);
416 printf("\n");
417 return;
418 }
419
420 sc->sc_ats = shutdownhook_establish((void (*)(void *)) pdq_hwreset, sc->sc_pdq);
421 if (sc->sc_ats == NULL)
422 printf("%s: warning: couldn't establish shutdown hook\n", self->dv_xname);
423 if (intrstr != NULL)
424 printf("%s: interrupting at %s\n", self->dv_xname, intrstr);
425}
426
427struct cfattach fpa_ca = {
428 sizeof(pdq_softc_t), pdq_pci_match, pdq_pci_attach
429};
430
431struct cfdriver fpa_cd = {
432 0, "fpa", DV_IFNET
433};
434
435#endif /* __NetBSD__ */