if_ntwoc_pci.c revision 1.20 1 /* $NetBSD: if_ntwoc_pci.c,v 1.20 2007/10/19 12:00:47 ad Exp $ */
2
3 /*
4 * Copyright (c) 1998 Vixie Enterprises
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of Vixie Enterprises nor the names
17 * of its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY VIXIE ENTERPRISES AND
21 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
22 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 * DISCLAIMED. IN NO EVENT SHALL VIXIE ENTERPRISES OR
25 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
28 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
29 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * This software has been written for Vixie Enterprises by Michael Graff
35 * <explorer (at) flame.org>. To learn more about Vixie Enterprises, see
36 * ``http://www.vix.com''.
37 */
38
39 #include <sys/cdefs.h>
40 __KERNEL_RCSID(0, "$NetBSD: if_ntwoc_pci.c,v 1.20 2007/10/19 12:00:47 ad Exp $");
41
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/device.h>
45 #include <sys/mbuf.h>
46 #include <sys/socket.h>
47
48 #include <net/if.h>
49
50 #include <sys/cpu.h>
51 #include <sys/bus.h>
52 #include <sys/intr.h>
53
54 #include <dev/pci/pcivar.h>
55 #include <dev/pci/pcireg.h>
56 #include <dev/pci/pcidevs.h>
57
58 #include <dev/ic/hd64570reg.h>
59 #include <dev/ic/hd64570var.h>
60
61 #include <dev/pci/if_ntwoc_pcireg.h>
62
63 #if 0
64 #define NTWO_DEBUG
65 #endif
66
67 #ifdef NTWO_DEBUG
68 #define NTWO_DPRINTF(x) printf x
69 #else
70 #define NTWO_DPRINTF(x)
71 #endif
72
73 /*
74 * buffers per tx and rx channels, per port, and the size of each.
75 * Don't use these constants directly, as they are really only hints.
76 * Use the calculated values stored in struct sca_softc instead.
77 *
78 * Each must be at least 2, receive would be better at around 20 or so.
79 *
80 * XXX Due to a damned near impossible to track down bug, transmit buffers
81 * MUST be 2, no more, no less.
82 */
83 #ifndef NTWOC_NtxBUFS
84 #define NTWOC_NtxBUFS 40
85 #endif
86 #ifndef NTWOC_NrxBUFS
87 #define NTWOC_NrxBUFS 20
88 #endif
89
90 #if __NetBSD_Version__ >= 104160000
91 static void ntwoc_pci_config_interrupts(struct device *);
92 #else
93 #define SCA_BASECLOCK 16000000
94 #endif
95
96 /*
97 * Card specific config register location
98 */
99 #define PCI_CBMA_ASIC 0x10 /* Configuration Base Memory Address */
100 #define PCI_CBMA_SCA 0x18
101
102 struct ntwoc_pci_softc {
103 /* Generic device stuff */
104 struct device sc_dev; /* Common to all devices */
105
106 /* PCI chipset glue */
107 pci_intr_handle_t *sc_ih; /* Interrupt handler */
108 pci_chipset_tag_t sc_sr; /* PCI chipset handle */
109
110 bus_space_tag_t sc_asic_iot; /* space cookie (for ASIC) */
111 bus_space_handle_t sc_asic_ioh; /* bus space handle (for ASIC) */
112
113 struct sca_softc sc_sca; /* the SCA itself */
114 };
115
116 static int ntwoc_pci_match(struct device *, struct cfdata *, void *);
117 static void ntwoc_pci_attach(struct device *, struct device *, void *);
118
119 static int ntwoc_pci_alloc_dma(struct sca_softc *);
120 static void ntwoc_pci_clock_callback(void *, int, int);
121 static void ntwoc_pci_dtr_callback(void *, int, int);
122 static void ntwoc_pci_get_clock(struct sca_port *, u_int8_t, u_int8_t,
123 u_int8_t, u_int8_t);
124 static int ntwoc_pci_intr(void *);
125 static void ntwoc_pci_setup_dma(struct sca_softc *);
126 static void ntwoc_pci_shutdown(void *sc);
127
128 CFATTACH_DECL(ntwoc_pci, sizeof(struct ntwoc_pci_softc),
129 ntwoc_pci_match, ntwoc_pci_attach, NULL, NULL);
130
131 /*
132 * Names for daughter card types. These match the NTWOC_DB_* defines.
133 */
134 const char *ntwoc_pci_db_names[] = {
135 "V.35", "Unknown 0x01", "Test", "Unknown 0x03",
136 "RS232", "Unknown 0x05", "RS422", "None"
137 };
138
139 /*
140 * At least one implementation uses a somewhat strange register address
141 * mapping. If a card doesn't, define this to be a pass-through
142 * macro. (The ntwo driver needs this...)
143 */
144 #define SCA_REG(y) (((y) & 0x0002) ? (((y) & 0x00fd) + 0x100) : (y))
145
146 /*
147 * functions that read and write to the sca registers
148 */
149 static void
150 ntwoc_pci_sca_write_1(struct sca_softc *sc, u_int reg, u_int8_t val)
151 {
152 bus_space_write_1(sc->sc_iot, sc->sc_ioh, SCA_REG(reg), val);
153 }
154
155 static void
156 ntwoc_pci_sca_write_2(struct sca_softc *sc, u_int reg, u_int16_t val)
157 {
158 bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCA_REG(reg), val);
159 }
160
161 static u_int8_t
162 ntwoc_pci_sca_read_1(struct sca_softc *sc, u_int reg)
163 {
164 return
165 bus_space_read_1(sc->sc_iot, sc->sc_ioh, SCA_REG(reg));
166 }
167
168 static u_int16_t
169 ntwoc_pci_sca_read_2(struct sca_softc *sc, u_int reg)
170 {
171 return
172 bus_space_read_2(sc->sc_iot, sc->sc_ioh, SCA_REG(reg));
173 }
174
175
176
177 static int
178 ntwoc_pci_match(struct device *parent, struct cfdata *match,
179 void *aux)
180 {
181 struct pci_attach_args *pa = (struct pci_attach_args *)aux;
182
183 if ((PCI_VENDOR(pa->pa_id) == PCI_VENDOR_RISCOM)
184 && (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_RISCOM_N2))
185 return 1;
186
187 return 0;
188 }
189
190 static void
191 ntwoc_pci_attach(struct device *parent, struct device *self, void *aux)
192 {
193 struct ntwoc_pci_softc *sc = (void *)self;
194 struct pci_attach_args *pa = aux;
195 struct sca_softc *sca = &sc->sc_sca;
196 pci_intr_handle_t ih;
197 const char *intrstr;
198 pcireg_t csr;
199 u_int8_t tmc, rdiv, tdiv;
200 u_int16_t frontend_cr;
201 u_int16_t db0, db1;
202 u_int32_t flags;
203 u_int numports;
204
205 printf(": N2 Serial Interface\n");
206 flags = device_cfdata(&sc->sc_dev)->cf_flags;
207
208 /*
209 * Map in the ASIC configuration space
210 */
211 if (pci_mapreg_map(pa, PCI_CBMA_ASIC, PCI_MAPREG_TYPE_MEM, 0,
212 &sc->sc_asic_iot, &sc->sc_asic_ioh, NULL, NULL)) {
213 printf("%s: Can't map register space (ASIC)\n",
214 sc->sc_dev.dv_xname);
215 return;
216 }
217 /*
218 * Map in the serial controller configuration space
219 */
220 if (pci_mapreg_map(pa, PCI_CBMA_SCA, PCI_MAPREG_TYPE_MEM, 0,
221 &sca->sc_iot, &sca->sc_ioh, NULL, NULL)) {
222 printf("%s: Can't map register space (SCA)\n",
223 sc->sc_dev.dv_xname);
224 return;
225 }
226
227 /*
228 * Enable the card
229 */
230 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
231 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, csr);
232
233 /*
234 * Map and establish the interrupt
235 */
236 if (pci_intr_map(pa, &ih)) {
237 printf("%s: couldn't map interrupt\n", sc->sc_dev.dv_xname);
238 return;
239 }
240 intrstr = pci_intr_string(pa->pa_pc, ih);
241 sc->sc_ih = pci_intr_establish(pa->pa_pc, ih, IPL_NET, ntwoc_pci_intr,
242 sc);
243 if (sc->sc_ih == NULL) {
244 printf("%s: couldn't establish interrupt",
245 sc->sc_dev.dv_xname);
246 if (intrstr != NULL)
247 printf(" at %s", intrstr);
248 printf("\n");
249 return;
250 }
251 printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname, intrstr);
252
253 /*
254 * Perform total black magic. This is not only extremely
255 * disgusting, but it should be explained a lot more in the
256 * card's documentation.
257 *
258 * From what I gather, this does nothing more than configure the
259 * PCI to ISA translator ASIC the N2pci card uses.
260 *
261 * From the FreeBSD driver:
262 * offset
263 * 0x00 - Map Range - Mem-mapped to locate anywhere
264 * 0x04 - Re-Map - PCI address decode enable
265 * 0x18 - Bus Region - 32-bit bus, ready enable
266 * 0x1c - Master Range - include all 16 MB
267 * 0x20 - Master RAM - Map SCA Base at 0
268 * 0x28 - Master Remap - direct master memory enable
269 * 0x68 - Interrupt - Enable interrupt (0 to disable)
270 */
271 bus_space_write_4(sc->sc_asic_iot, sc->sc_asic_ioh,
272 0x00, 0xfffff000);
273 bus_space_write_4(sc->sc_asic_iot, sc->sc_asic_ioh,
274 0x04, 1);
275 bus_space_write_4(sc->sc_asic_iot, sc->sc_asic_ioh,
276 0x18, 0x40030043);
277 bus_space_write_4(sc->sc_asic_iot, sc->sc_asic_ioh,
278 0x1c, 0xff000000);
279 bus_space_write_4(sc->sc_asic_iot, sc->sc_asic_ioh,
280 0x20, 0);
281 bus_space_write_4(sc->sc_asic_iot, sc->sc_asic_ioh,
282 0x28, 0xe9);
283 bus_space_write_4(sc->sc_asic_iot, sc->sc_asic_ioh,
284 0x68, 0x10900);
285
286 /*
287 * pass the DMA tag to the SCA
288 */
289 sca->sc_usedma = 1;
290 sca->scu_dmat = pa->pa_dmat;
291
292 /*
293 * Read the configuration information off the daughter card.
294 */
295 frontend_cr = bus_space_read_2(sca->sc_iot, sca->sc_ioh, NTWOC_FECR);
296 NTWO_DPRINTF(("%s: frontend_cr = 0x%04x\n",
297 sc->sc_dev.dv_xname, frontend_cr));
298
299 db0 = (frontend_cr & NTWOC_FECR_ID0) >> NTWOC_FECR_ID0_SHIFT;
300 db1 = (frontend_cr & NTWOC_FECR_ID1) >> NTWOC_FECR_ID1_SHIFT;
301
302 /*
303 * Port 1 HAS to be present. If it isn't, don't attach anything.
304 */
305 if (db0 == NTWOC_FE_ID_NONE) {
306 printf("%s: no ports available\n", sc->sc_dev.dv_xname);
307 return;
308 }
309
310 /*
311 * Port 1 is present. Now, check to see if port 2 is also
312 * present.
313 */
314 numports = 1;
315 if (db1 != NTWOC_FE_ID_NONE)
316 numports++;
317
318 printf("%s: %d port%s\n", sc->sc_dev.dv_xname, numports,
319 (numports > 1 ? "s" : ""));
320 printf("%s: port 0 interface card: %s\n", sc->sc_dev.dv_xname,
321 ntwoc_pci_db_names[db0]);
322 if (numports > 1)
323 printf("%s: port 1 interface card: %s\n", sc->sc_dev.dv_xname,
324 ntwoc_pci_db_names[db1]);
325
326 /*
327 * enable the RS422 tristate transmit
328 * diable clock output (use receiver clock for both)
329 */
330 frontend_cr |= (NTWOC_FECR_TE0 | NTWOC_FECR_TE1);
331 frontend_cr &= ~(NTWOC_FECR_ETC0 | NTWOC_FECR_ETC1);
332 bus_space_write_2(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh,
333 NTWOC_FECR, frontend_cr);
334
335 /*
336 * initialize the SCA. This will allocate DMAable memory based
337 * on the number of ports we passed in, the size of each
338 * buffer, and the number of buffers per port.
339 */
340 sca->sc_parent = &sc->sc_dev;
341 sca->sc_read_1 = ntwoc_pci_sca_read_1;
342 sca->sc_read_2 = ntwoc_pci_sca_read_2;
343 sca->sc_write_1 = ntwoc_pci_sca_write_1;
344 sca->sc_write_2 = ntwoc_pci_sca_write_2;
345 sca->sc_dtr_callback = ntwoc_pci_dtr_callback;
346 sca->sc_clock_callback = ntwoc_pci_clock_callback;
347 sca->sc_aux = sc;
348 sca->sc_numports = numports;
349
350 /*
351 * get clock information from user
352 */
353 rdiv = (flags & NTWOC_FLAGS_RXDIV_MASK) >> NTWOC_FLAGS_RXDIV_SHIFT;
354 if (rdiv > 9)
355 panic("bad rx divisor in flags");
356
357 tdiv = (flags & NTWOC_FLAGS_TXDIV_MASK) >> NTWOC_FLAGS_TXDIV_SHIFT;
358 if (tdiv > 9)
359 panic("bad tx divisor in flags");
360 tmc = (flags & NTWOC_FLAGS_TMC_MASK) >> NTWOC_FLAGS_TMC_SHIFT;
361
362 ntwoc_pci_get_clock(&sca->sc_ports[0], flags & NTWOC_FLAGS_CLK0_MASK,
363 tmc, rdiv, tdiv);
364 if (sca->sc_numports > 1)
365 ntwoc_pci_get_clock(&sca->sc_ports[1],
366 (flags & NTWOC_FLAGS_CLK1_MASK) >> NTWOC_FLAGS_CLK1_SHIFT,
367 tmc, rdiv, tdiv);
368
369 /* allocate DMA'able memory for card to use */
370 ntwoc_pci_alloc_dma(sca);
371 ntwoc_pci_setup_dma(sca);
372
373 sca_init(sca);
374
375 /*
376 * always initialize port 0, since we have to have found it to
377 * get this far. If we have two ports, attach the second
378 * as well.
379 */
380 sca_port_attach(sca, 0);
381 if (numports == 2)
382 sca_port_attach(sca, 1);
383
384 /*
385 * Add shutdown hook so that DMA is disabled prior to reboot. Not
386 * doing do could allow DMA to corrupt kernel memory during the
387 * reboot before the driver initializes.
388 */
389 shutdownhook_establish(ntwoc_pci_shutdown, sc);
390
391 #if __NetBSD_Version__ >= 104160000
392 /*
393 * defer getting the base clock until interrupts are enabled
394 * (and thus we have microtime())
395 */
396 config_interrupts(self, ntwoc_pci_config_interrupts);
397 #else
398 sca->sc_baseclock = SCA_BASECLOCK;
399 sca_print_clock_info(&sc->sc_sca);
400 #endif
401 }
402
403 /*
404 * extract the clock information for a port from the flags field
405 */
406 static void
407 ntwoc_pci_get_clock(struct sca_port *scp, u_int8_t flags, u_int8_t tmc,
408 u_int8_t rdiv, u_int8_t tdiv)
409 {
410 scp->sp_eclock =
411 (flags & NTWOC_FLAGS_ECLOCK_MASK) >> NTWOC_FLAGS_ECLOCK_SHIFT;
412 scp->sp_rxs = rdiv;
413 scp->sp_txs = tdiv;
414 scp->sp_tmc = tmc;
415
416 /* get rx source */
417 switch ((flags & NTWOC_FLAGS_RXS_MASK) >> NTWOC_FLAGS_RXS_SHIFT) {
418 case NTWOC_FLAGS_RXS_LINE:
419 scp->sp_rxs = 0;
420 break;
421 case NTWOC_FLAGS_RXS_LINE_SN:
422 scp->sp_rxs |= SCA_RXS_CLK_LINE_SN;
423 break;
424 case NTWOC_FLAGS_RXS_INTERNAL:
425 scp->sp_rxs |= SCA_RXS_CLK_INTERNAL;
426 break;
427 case NTWOC_FLAGS_RXS_ADPLL_OUT:
428 scp->sp_rxs |= SCA_RXS_CLK_ADPLL_OUT;
429 break;
430 case NTWOC_FLAGS_RXS_ADPLL_IN:
431 scp->sp_rxs |= SCA_RXS_CLK_ADPLL_IN;
432 break;
433 default:
434 panic("bad rx source in flags");
435 }
436
437 /* get tx source */
438 switch ((flags & NTWOC_FLAGS_TXS_MASK) >> NTWOC_FLAGS_TXS_SHIFT) {
439 case NTWOC_FLAGS_TXS_LINE:
440 scp->sp_txs = 0;
441 break;
442 case NTWOC_FLAGS_TXS_INTERNAL:
443 scp->sp_txs |= SCA_TXS_CLK_INTERNAL;
444 break;
445 case NTWOC_FLAGS_TXS_RXCLOCK:
446 scp->sp_txs |= SCA_TXS_CLK_RXCLK;
447 break;
448 default:
449 panic("bad rx source in flags");
450 }
451 }
452
453
454 static int
455 ntwoc_pci_intr(void *arg)
456 {
457 struct ntwoc_pci_softc *sc = (struct ntwoc_pci_softc *)arg;
458
459 return sca_hardintr(&sc->sc_sca);
460 }
461
462 /*
463 * shut down interrupts and DMA, so we don't trash the kernel on warm
464 * boot. Also, lower DTR on each port and disable card interrupts.
465 */
466 static void
467 ntwoc_pci_shutdown(void *aux)
468 {
469 struct ntwoc_pci_softc *sc = aux;
470 u_int16_t fecr;
471
472 /*
473 * shut down the SCA ports
474 */
475 sca_shutdown(&sc->sc_sca);
476
477 /*
478 * disable interrupts for the whole card. Black magic, see comment
479 * above.
480 */
481 bus_space_write_4(sc->sc_asic_iot, sc->sc_asic_ioh,
482 0x68, 0x10900);
483
484 /*
485 * lower DTR on both ports
486 */
487 fecr = bus_space_read_2(sc->sc_sca.sc_iot,
488 sc->sc_sca.sc_ioh, NTWOC_FECR);
489 fecr |= (NTWOC_FECR_DTR0 | NTWOC_FECR_DTR1);
490 bus_space_write_2(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh,
491 NTWOC_FECR, fecr);
492 }
493
494 static void
495 ntwoc_pci_dtr_callback(void *aux, int port, int state)
496 {
497 struct ntwoc_pci_softc *sc = aux;
498 u_int16_t fecr;
499
500 fecr = bus_space_read_2(sc->sc_sca.sc_iot,
501 sc->sc_sca.sc_ioh, NTWOC_FECR);
502
503 NTWO_DPRINTF(("dtr: port == %d, state == %d, old fecr: 0x%04x\n",
504 port, state, fecr));
505
506 if (port == 0) {
507 if (state == 0)
508 fecr |= NTWOC_FECR_DTR0;
509 else
510 fecr &= ~NTWOC_FECR_DTR0;
511 } else {
512 if (state == 0)
513 fecr |= NTWOC_FECR_DTR1;
514 else
515 fecr &= ~NTWOC_FECR_DTR1;
516 }
517
518 NTWO_DPRINTF(("new fecr: 0x%04x\n", fecr));
519
520 bus_space_write_2(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh,
521 NTWOC_FECR, fecr);
522 }
523
524 static void
525 ntwoc_pci_clock_callback(void *aux, int port, int enable)
526 {
527 struct ntwoc_pci_softc *sc = aux;
528 u_int16_t fecr;
529
530 fecr = bus_space_read_2(sc->sc_sca.sc_iot,
531 sc->sc_sca.sc_ioh, NTWOC_FECR);
532
533 NTWO_DPRINTF(("clk: port == %d, enable == %d, old fecr: 0x%04x\n",
534 port, enable, fecr));
535
536 if (port == 0) {
537 if (enable)
538 fecr |= NTWOC_FECR_ETC0;
539 else
540 fecr &= ~NTWOC_FECR_ETC0;
541 } else {
542 if (enable)
543 fecr |= NTWOC_FECR_ETC1;
544 else
545 fecr &= ~NTWOC_FECR_ETC1;
546 }
547
548 NTWO_DPRINTF(("new fecr: 0x%04x\n", fecr));
549
550 bus_space_write_2(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh,
551 NTWOC_FECR, fecr);
552 }
553
554 static int
555 ntwoc_pci_alloc_dma(struct sca_softc *sc)
556 {
557 u_int allocsize;
558 int err;
559 int rsegs;
560 u_int bpp;
561
562 /* first initialize the number of descriptors */
563 sc->sc_ports[0].sp_nrxdesc = NTWOC_NrxBUFS;
564 sc->sc_ports[0].sp_ntxdesc = NTWOC_NtxBUFS;
565 if (sc->sc_numports == 2) {
566 sc->sc_ports[1].sp_nrxdesc = NTWOC_NrxBUFS;
567 sc->sc_ports[1].sp_ntxdesc = NTWOC_NtxBUFS;
568 }
569
570 NTWO_DPRINTF(("sizeof sca_desc_t: %d bytes\n", sizeof (sca_desc_t)));
571
572 bpp = sc->sc_numports * (NTWOC_NtxBUFS + NTWOC_NrxBUFS);
573
574 allocsize = bpp * (SCA_BSIZE + sizeof (sca_desc_t));
575
576 /*
577 * sanity checks:
578 *
579 * Check the total size of the data buffers, and so on. The total
580 * DMAable space needs to fit within a single 16M region, and the
581 * descriptors need to fit within a 64K region.
582 */
583 if (allocsize > 16 * 1024 * 1024)
584 return 1;
585 if (bpp * sizeof (sca_desc_t) > 64 * 1024)
586 return 1;
587
588 sc->scu_allocsize = allocsize;
589
590 /*
591 * Allocate one huge chunk of memory.
592 */
593 if (bus_dmamem_alloc(sc->scu_dmat,
594 allocsize,
595 SCA_DMA_ALIGNMENT,
596 SCA_DMA_BOUNDARY,
597 &sc->scu_seg, 1, &rsegs, BUS_DMA_NOWAIT) != 0) {
598 printf("Could not allocate DMA memory\n");
599 return 1;
600 }
601 NTWO_DPRINTF(("DMA memory allocated: %d bytes\n", allocsize));
602
603 if (bus_dmamem_map(sc->scu_dmat, &sc->scu_seg, 1, allocsize,
604 &sc->scu_dma_addr, BUS_DMA_NOWAIT) != 0) {
605 printf("Could not map DMA memory into kernel space\n");
606 return 1;
607 }
608 NTWO_DPRINTF(("DMA memory mapped\n"));
609
610 if (bus_dmamap_create(sc->scu_dmat, allocsize, 2,
611 allocsize, SCA_DMA_BOUNDARY,
612 BUS_DMA_NOWAIT, &sc->scu_dmam) != 0) {
613 printf("Could not create DMA map\n");
614 return 1;
615 }
616 NTWO_DPRINTF(("DMA map created\n"));
617
618 err = bus_dmamap_load(sc->scu_dmat, sc->scu_dmam, sc->scu_dma_addr,
619 allocsize, NULL, BUS_DMA_NOWAIT);
620 if (err != 0) {
621 printf("Could not load DMA segment: %d\n", err);
622 return 1;
623 }
624 NTWO_DPRINTF(("DMA map loaded\n"));
625
626 return 0;
627 }
628
629 /*
630 * Take the memory allocated with sca_alloc_dma() and divide it among the
631 * two ports.
632 */
633 static void
634 ntwoc_pci_setup_dma(struct sca_softc *sc)
635 {
636 sca_port_t *scp0, *scp1;
637 u_int8_t *vaddr0;
638 u_int32_t paddr0;
639 u_long addroff;
640
641 /*
642 * remember the physical address to 24 bits only, since the upper
643 * 8 bits is programed into the device at a different layer.
644 */
645 paddr0 = (sc->scu_dmam->dm_segs[0].ds_addr & 0x00ffffff);
646 vaddr0 = sc->scu_dma_addr;
647
648 /*
649 * if we have only one port it gets the full range. If we have
650 * two we need to do a little magic to divide things up.
651 *
652 * The descriptors will all end up in the front of the area, while
653 * the remainder of the buffer is used for transmit and receive
654 * data.
655 *
656 * -------------------- start of memory
657 * tx desc port 0
658 * rx desc port 0
659 * tx desc port 1
660 * rx desc port 1
661 * tx buffer port 0
662 * rx buffer port 0
663 * tx buffer port 1
664 * rx buffer port 1
665 * -------------------- end of memory
666 */
667 scp0 = &sc->sc_ports[0];
668 scp1 = &sc->sc_ports[1];
669
670 scp0->sp_txdesc_p = paddr0;
671 scp0->sp_txdesc = (sca_desc_t *)vaddr0;
672 addroff = sizeof(sca_desc_t) * scp0->sp_ntxdesc;
673
674 /*
675 * point to the range following the tx descriptors, and
676 * set the rx descriptors there.
677 */
678 scp0->sp_rxdesc_p = paddr0 + addroff;
679 scp0->sp_rxdesc = (sca_desc_t *)(vaddr0 + addroff);
680 addroff += sizeof(sca_desc_t) * scp0->sp_nrxdesc;
681
682 if (sc->sc_numports == 2) {
683 scp1->sp_txdesc_p = paddr0 + addroff;
684 scp1->sp_txdesc = (sca_desc_t *)(vaddr0 + addroff);
685 addroff += sizeof(sca_desc_t) * scp1->sp_ntxdesc;
686
687 scp1->sp_rxdesc_p = paddr0 + addroff;
688 scp1->sp_rxdesc = (sca_desc_t *)(vaddr0 + addroff);
689 addroff += sizeof(sca_desc_t) * scp1->sp_nrxdesc;
690 }
691
692 /*
693 * point to the memory following the descriptors, and set the
694 * transmit buffer there.
695 */
696 scp0->sp_txbuf_p = paddr0 + addroff;
697 scp0->sp_txbuf = vaddr0 + addroff;
698 addroff += SCA_BSIZE * scp0->sp_ntxdesc;
699
700 /*
701 * lastly, skip over the transmit buffer and set up pointers into
702 * the receive buffer.
703 */
704 scp0->sp_rxbuf_p = paddr0 + addroff;
705 scp0->sp_rxbuf = vaddr0 + addroff;
706 addroff += SCA_BSIZE * scp0->sp_nrxdesc;
707
708 if (sc->sc_numports == 2) {
709 scp1->sp_txbuf_p = paddr0 + addroff;
710 scp1->sp_txbuf = vaddr0 + addroff;
711 addroff += SCA_BSIZE * scp1->sp_ntxdesc;
712
713 scp1->sp_rxbuf_p = paddr0 + addroff;
714 scp1->sp_rxbuf = vaddr0 + addroff;
715 addroff += SCA_BSIZE * scp1->sp_nrxdesc;
716 }
717
718 /*
719 * as a consistancy check, addroff should be equal to the allocation
720 * size.
721 */
722 if (sc->scu_allocsize != addroff)
723 printf("ERROR: scu_allocsize != addroff: %lu != %lu\n",
724 (u_long)sc->scu_allocsize, addroff);
725 }
726
727 #if __NetBSD_Version__ >= 104160000
728 static void
729 ntwoc_pci_config_interrupts(self)
730 struct device *self;
731 {
732 struct ntwoc_pci_softc *sc;
733
734 sc = (void *)self;
735 sca_get_base_clock(&sc->sc_sca);
736 sca_print_clock_info(&sc->sc_sca);
737 }
738 #endif
739