Home | History | Annotate | Line # | Download | only in pci
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