1 /* $NetBSD: if_ntwoc_isa.c,v 1.27 2016/07/14 10:19:06 msaitoh Exp $ */ 2 /* 3 * Copyright (c) 1999 Christian E. Hopps 4 * Copyright (c) 1996 John Hay. 5 * Copyright (c) 1996 SDL Communications, Inc. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 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 the author nor the names of any co-contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $Id: if_ntwoc_isa.c,v 1.27 2016/07/14 10:19:06 msaitoh Exp $ 33 */ 34 35 #include <sys/cdefs.h> 36 __KERNEL_RCSID(0, "$NetBSD: if_ntwoc_isa.c,v 1.27 2016/07/14 10:19:06 msaitoh Exp $"); 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/device.h> 41 #include <sys/mbuf.h> 42 #include <sys/socket.h> 43 44 #include <net/if.h> 45 46 #include <sys/cpu.h> 47 #include <sys/bus.h> 48 #include <sys/intr.h> 49 50 #include <dev/isa/isavar.h> 51 52 #include <dev/ic/hd64570reg.h> 53 #include <dev/ic/hd64570var.h> 54 55 #include <dev/isa/if_ntwoc_isareg.h> 56 57 #if 1 58 #define NTWO_DEBUG 59 #endif 60 61 #ifdef NTWO_DEBUG 62 #define NTWO_DPRINTF(x) printf x 63 #else 64 #define NTWO_DPRINTF(x) 65 #endif 66 67 #if __NetBSD_Version__ >= 104160000 68 static void ntwoc_isa_config_interrupts(device_t); 69 #else 70 #define SCA_BASECLOCK 9830400 71 #endif 72 73 /* hard core 16k for now */ 74 #define NTWOC_WIN_SIZE 0x4000 75 76 struct ntwoc_isa_softc { 77 /* Generic device stuff */ 78 device_t sc_dev; /* Common to all devices */ 79 80 /* PCI chipset glue */ 81 void *sc_ih; /* Interrupt handler */ 82 isa_chipset_tag_t sc_ic; /* ISA chipset handle */ 83 84 struct sca_softc sc_sca; /* the SCA itself */ 85 }; 86 87 static int ntwoc_isa_probe(device_t, cfdata_t, void *); 88 static void ntwoc_isa_attach(device_t, device_t, void *); 89 90 static void ntwoc_isa_clock_callback(void *, int, int); 91 static void ntwoc_isa_dtr_callback(void *, int, int); 92 static int ntwoc_isa_intr(void *); 93 static void ntwoc_isa_get_clock(struct sca_port *, u_int8_t, u_int8_t, 94 u_int8_t, u_int8_t); 95 static void ntwoc_isa_setup_memory(struct sca_softc *sc); 96 static void ntwoc_isa_shutdown(void *sc); 97 98 CFATTACH_DECL_NEW(ntwoc_isa, sizeof(struct ntwoc_isa_softc), 99 ntwoc_isa_probe, ntwoc_isa_attach, NULL, NULL); 100 101 /* 102 * Names for daughter card types. These match the NTWOC_DB_* defines. 103 */ 104 const char *ntwoc_db_names[] = { 105 "V.35", "Unknown 0x01", "Test", "Unknown 0x03", 106 "RS232", "Unknown 0x05", "RS422", "None" 107 }; 108 109 /* some weird offset XXX */ 110 #define SCA_REG(r) (((r) & 0xf) + (((r) & 0xf0) << 6)) 111 112 /* 113 * functions that read and write to the sca registers 114 */ 115 static void 116 ntwoc_isa_sca_write_1(struct sca_softc *sc, u_int reg, u_int8_t val) 117 { 118 bus_space_write_1(sc->sc_iot, sc->scu_sca_ioh[(reg & 0xf0) >> 4], 119 (reg & 0xf), val); 120 } 121 122 static void 123 ntwoc_isa_sca_write_2(struct sca_softc *sc, u_int reg, u_int16_t val) 124 { 125 bus_space_write_2(sc->sc_iot, sc->scu_sca_ioh[(reg & 0xf0) >> 4], 126 (reg & 0xf), val); 127 } 128 129 static u_int8_t 130 ntwoc_isa_sca_read_1(struct sca_softc *sc, u_int reg) 131 { 132 return 133 bus_space_read_1(sc->sc_iot, sc->scu_sca_ioh[(reg & 0xf0) >> 4], 134 (reg & 0xf)); 135 } 136 137 static u_int16_t 138 ntwoc_isa_sca_read_2(struct sca_softc *sc, u_int reg) 139 { 140 return 141 bus_space_read_2(sc->sc_iot, sc->scu_sca_ioh[(reg & 0xf0) >> 4], 142 (reg & 0xf)); 143 } 144 145 /* 146 * set the correct window/page 147 */ 148 static void 149 ntwoc_isa_set_page(struct sca_softc *sca, bus_addr_t addr) 150 { 151 u_int8_t psr; 152 153 /* get old psr value replace old window with new */ 154 psr = bus_space_read_1(sca->sc_iot, sca->sc_ioh, NTWOC_PSR); 155 psr &= ~NTWOC_PG_MSK; 156 psr |= ((addr >> sca->scu_pageshift) & NTWOC_PG_MSK); 157 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PSR, psr); 158 } 159 160 /* 161 * enable the memory window 162 */ 163 static void 164 ntwoc_isa_set_on(struct sca_softc *sca) 165 { 166 u_int8_t pcr; 167 168 /* get old value and add window enable */ 169 pcr = bus_space_read_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR); 170 pcr |= NTWOC_PCR_MEM_WIN; 171 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR, pcr); 172 } 173 174 /* 175 * turn off memory window 176 */ 177 static void 178 ntwoc_isa_set_off(struct sca_softc *sca) 179 { 180 u_int8_t pcr; 181 182 /* get old value and remove window enable */ 183 pcr = bus_space_read_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR); 184 pcr &= ~NTWOC_PCR_MEM_WIN; 185 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR, pcr); 186 } 187 188 static int 189 ntwoc_isa_probe(device_t parent, cfdata_t match, void *aux) 190 { 191 struct isa_attach_args *ia; 192 bus_space_tag_t iot, memt; 193 bus_space_handle_t ioh, memh, sca_ioh[16]; 194 int i, tmp, rv; 195 int gotmem, gotsca[16]; 196 u_int32_t ioport; 197 198 ia = (struct isa_attach_args *)aux; 199 iot = ia->ia_iot; 200 memt = ia->ia_memt; 201 202 if (ia->ia_nio < 1) 203 return (0); 204 if (ia->ia_niomem < 1) 205 return (0); 206 if (ia->ia_nirq < 1) 207 return (0); 208 209 if (ISA_DIRECT_CONFIG(ia)) 210 return (0); 211 212 memset(gotsca, 0, sizeof(gotsca)); 213 gotmem = rv = 0; 214 215 /* disallow wildcarded I/O base */ 216 if (ia->ia_io[0].ir_addr == ISA_UNKNOWN_PORT) { 217 printf("ntwoc_isa_probe: must specify port address\n"); 218 return (0); 219 } 220 221 if (ia->ia_irq[0].ir_irq == ISA_UNKNOWN_IRQ) { 222 printf("ntwoc_isa_probe: must specify irq\n"); 223 return (0); 224 } 225 226 if (ia->ia_iomem[0].ir_addr == ISA_UNKNOWN_IOMEM) { 227 printf("ntwoc_isa_probe: must specify iomem\n"); 228 return (0); 229 } 230 231 tmp = (match->cf_flags & NTWOC_FLAGS_NPORT_MASK) + 1; 232 if (tmp < 1 || tmp > 2) { 233 printf("ntwoc_isa_probe: only 1 or 2 ports allowed\n"); 234 return (0); 235 } 236 237 /* map the isa io addresses */ 238 if ((tmp = bus_space_map(iot, ia->ia_io[0].ir_addr, 239 NTWOC_SRC_IOPORT_SIZE, 0, &ioh))) { 240 printf("ntwoc_isa_probe: mapping port 0x%x sz %d failed: %d\n", 241 ia->ia_io[0].ir_addr, NTWOC_SRC_IOPORT_SIZE, tmp); 242 return (0); 243 } 244 245 ioport = ia->ia_io[0].ir_addr + 0x8000; 246 for (i = 0; i < 16; ioport += (0x10 << 6), i++) { 247 /* map the isa io addresses */ 248 if ((tmp = bus_space_map(iot, ioport, 16, 0, &sca_ioh[i]))) { 249 printf( 250 "ntwoc_isa_probe: mapping sca 0x%x sz %d failed: %d\n", 251 ioport, 16, tmp); 252 goto out; 253 } 254 gotsca[i] = 1; 255 } 256 257 /* map the isa memory addresses */ 258 /* XXX we really want the user to select this */ 259 if ((tmp = bus_space_map(ia->ia_memt, ia->ia_iomem[0].ir_addr, 260 NTWOC_WIN_SIZE, 0, &memh))) { 261 printf("ntwoc_isa_probe: mapping mem 0x%x sz %d failed: %d\n", 262 ia->ia_iomem[0].ir_addr, NTWOC_WIN_SIZE, tmp); 263 goto out; 264 } 265 gotmem = 1; 266 267 /* turn off the card */ 268 bus_space_write_1(iot, ioh, NTWOC_PCR, 0); 269 270 /* 271 * Next, we'll test the Base Address Register to retension of 272 * data... ... seeing if we're *really* talking to an N2. 273 */ 274 for (i = 0; i < 0x100; i++) { 275 bus_space_write_1(iot, ioh, NTWOC_BAR, i); 276 (void)bus_space_read_1(iot, ioh, NTWOC_PCR); 277 if (bus_space_read_1(iot, ioh, NTWOC_BAR) != i) { 278 printf("ntwoc_isa_probe failed (BAR %x, %x)\n", i, tmp); 279 goto out; 280 } 281 } 282 283 /* XXX XXX update the calls to SCA_REG to use our mapping */ 284 285 /* 286 * Now see if we can see the SCA. 287 */ 288 bus_space_write_1(iot, ioh, NTWOC_PCR, 289 NTWOC_PCR_SCARUN | bus_space_read_1(iot, ioh, NTWOC_PCR)); 290 bus_space_write_1(iot, sca_ioh[0], SCA_REG(SCA_WCRL), 0); 291 bus_space_write_1(iot, sca_ioh[0], SCA_REG(SCA_WCRM), 0); 292 bus_space_write_1(iot, sca_ioh[0], SCA_REG(SCA_WCRH), 0); 293 bus_space_write_1(iot, sca_ioh[0], SCA_REG(SCA_PCR), 0); 294 295 bus_space_write_1(iot, sca_ioh[0], SCA_REG(SCA_TMC0), 0); 296 (void)bus_space_read_1(iot, ioh, 0); 297 if ((tmp = bus_space_read_1(iot, sca_ioh[0], SCA_REG(SCA_TMC0))) != 0) { 298 printf("ntwoc_isa_probe: Error reading SCA (TMC0 0, %x)\n", 299 tmp); 300 goto out; 301 } 302 303 bus_space_write_1(iot, sca_ioh[0], SCA_REG(SCA_TMC0), 0x5A); 304 (void)bus_space_read_1(iot, ioh, 0); 305 306 tmp = bus_space_read_1(iot, sca_ioh[0], SCA_REG(SCA_TMC0)); 307 if (tmp != 0x5A) { 308 printf("ntwoc_isa_probe: Error reading SCA (TMC0 5A, %x)\n", 309 tmp); 310 goto out; 311 } 312 313 bus_space_write_2(iot, sca_ioh[0], SCA_REG(SCA_CDAL0), 0); 314 (void)bus_space_read_1(iot, ioh, 0); 315 tmp = bus_space_read_2(iot, sca_ioh[0], SCA_REG(SCA_CDAL0)); 316 if (tmp != 0) { 317 printf("ntwoc_isa_probe: Error reading SCA (CDAL0 0, %x)\n", 318 tmp); 319 goto out; 320 } 321 322 bus_space_write_2(iot, sca_ioh[0], SCA_REG(SCA_CDAL0), 0x55AA); 323 (void)bus_space_read_1(iot, ioh, 0); 324 tmp = bus_space_read_2(iot, sca_ioh[0], SCA_REG(SCA_CDAL0)); 325 if (tmp != 0x55AA) { 326 printf("ntwoc_isa_probe: Error reading SCA (CDAL0 55AA, %x)\n", 327 tmp); 328 goto out; 329 } 330 331 /* 332 * I had a weird card that didn't function correctly on a certain 333 * newer MB. I suspect it was the whacky port addresses. 334 * The following correctly failed it. 335 */ 336 bus_space_write_2(iot, sca_ioh[0], SCA_REG(SCA_TCNTL0), 0x0); 337 (void)bus_space_read_1(iot, ioh, 0); 338 tmp = bus_space_read_2(iot, sca_ioh[0], SCA_REG(SCA_TCNTL0)); 339 if (tmp != 0) { 340 printf("ntwoc_isa_probe: Error reading SCA (TCNTL0 0, %x)\n", 341 tmp); 342 goto out; 343 } 344 345 bus_space_write_2(iot, sca_ioh[0], SCA_REG(SCA_TCNTL0), 0x55AA); 346 (void)bus_space_read_1(iot, ioh, 0); 347 tmp = bus_space_read_2(iot, sca_ioh[0], SCA_REG(SCA_TCNTL0)); 348 if (tmp != 0x55AA) { 349 printf("ntwoc_isa_probe: Error reading SCA (TCNTL0 55AA, %x)\n", 350 tmp); 351 goto out; 352 } 353 354 ia->ia_nio = 1; 355 ia->ia_io[0].ir_size = NTWOC_SRC_IOPORT_SIZE; 356 357 ia->ia_niomem = 1; 358 ia->ia_iomem[0].ir_size = NTWOC_WIN_SIZE; 359 360 ia->ia_nirq = 1; 361 362 ia->ia_ndrq = 0; 363 364 rv = 1; 365 out: 366 /* turn off the card */ 367 bus_space_write_1(iot, ioh, NTWOC_PCR, 0); 368 369 if (gotmem) 370 bus_space_unmap(memt, memh, NTWOC_WIN_SIZE); 371 for (i = 0; i < 16; i++) { 372 if (gotsca[i]) 373 bus_space_unmap(iot, sca_ioh[i], 16); 374 } 375 bus_space_unmap(iot, ioh, NTWOC_SRC_IOPORT_SIZE); 376 return (rv); 377 } 378 379 /* 380 * we win! attach the card 381 */ 382 static void 383 ntwoc_isa_attach(device_t parent, device_t self, void *aux) 384 { 385 struct ntwoc_isa_softc *sc; 386 struct isa_attach_args *ia; 387 struct sca_softc *sca; 388 bus_addr_t addr; 389 u_int8_t rdiv, tdiv, tmc; 390 u_int32_t flags, ioport; 391 u_int16_t tmp; 392 int i, pgs, rv; 393 394 ia = (struct isa_attach_args *)aux; 395 sc = device_private(self); 396 sc->sc_dev = self; 397 sca = &sc->sc_sca; 398 399 printf(": N2 Serial Interface\n"); 400 flags = device_cfdata(sc->sc_dev)->cf_flags; 401 402 sc->sc_ic = ia->ia_ic; 403 sca->sc_parent = sc->sc_dev; 404 sca->sc_numports = (flags & NTWOC_FLAGS_NPORT_MASK) + 1; 405 sca->sc_usedma = 0; 406 sca->sc_aux = sc; 407 sca->sc_dtr_callback = ntwoc_isa_dtr_callback; 408 sca->sc_clock_callback = ntwoc_isa_clock_callback; 409 sca->sc_read_1 = ntwoc_isa_sca_read_1; 410 sca->sc_read_2 = ntwoc_isa_sca_read_2; 411 sca->sc_write_1 = ntwoc_isa_sca_write_1; 412 sca->sc_write_2 = ntwoc_isa_sca_write_2; 413 sca->scu_set_page = ntwoc_isa_set_page; 414 sca->scu_page_on = ntwoc_isa_set_on; 415 sca->scu_page_off = ntwoc_isa_set_off; 416 417 /* map the io */ 418 sca->sc_iot = ia->ia_iot; 419 if ((rv = bus_space_map(ia->ia_iot, ia->ia_io[0].ir_addr, 420 NTWOC_SRC_IOPORT_SIZE, 0, &sca->sc_ioh))) { 421 aprint_error_dev(sc->sc_dev, "can't map io 0x%x sz %d, %d\n", 422 ia->ia_io[0].ir_addr, NTWOC_SRC_IOPORT_SIZE, rv); 423 return; 424 } 425 426 /* support weird mapping (they used this to avoid 10-bit aliasing) */ 427 ioport = ia->ia_io[0].ir_addr + 0x8000; 428 for (i = 0; i < 16; ioport += (0x10 << 6), i++) { 429 /* map the isa io addresses */ 430 if ((tmp = bus_space_map(ia->ia_iot, ioport, 16, 0, 431 &sca->scu_sca_ioh[i]))) { 432 aprint_error_dev(sc->sc_dev, 433 "mapping sca 0x%x sz %d failed: %d\n", 434 ioport, 16, tmp); 435 return; 436 } 437 } 438 439 /* map the isa memory */ 440 sca->scu_memt = ia->ia_memt; 441 sca->scu_pagesize = 0x4000; /* force 16k for now */ 442 if (sca->scu_pagesize < 0x8000) { 443 /* round down to 16k */ 444 sca->scu_pagesize = 0x4000; 445 sca->scu_pageshift = 14; 446 tmp = NTWOC_PSR_WIN_16K; 447 } else if (sca->scu_pagesize < 0x10000) { 448 /* round down to 32k */ 449 sca->scu_pagesize = 0x8000; 450 sca->scu_pageshift = 15; 451 tmp = NTWOC_PSR_WIN_32K; 452 } else if (sca->scu_pagesize < 0x20000) { 453 /* round down to 64k */ 454 sca->scu_pagesize = 0x10000; 455 sca->scu_pageshift = 16; 456 tmp = NTWOC_PSR_WIN_64K; 457 } else { 458 sca->scu_pagesize = 0x20000; 459 sca->scu_pageshift = 17; 460 tmp = NTWOC_PSR_WIN_128K; 461 } 462 sca->scu_pagemask = sca->scu_pagesize - 1; 463 if ((rv = bus_space_map(ia->ia_memt, ia->ia_iomem[0].ir_addr, 464 sca->scu_pagesize, 0, &sca->scu_memh))) { 465 aprint_error_dev(sc->sc_dev, "can't map mem 0x%x sz %ld, %d\n", 466 ia->ia_iomem[0].ir_addr, 467 (u_long)sca->scu_pagesize, rv); 468 return; 469 } 470 471 /* turn the card on!! */ 472 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR, 473 bus_space_read_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR) 474 | NTWOC_PCR_SCARUN); 475 476 /* set the window size to 16k */ 477 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PSR, tmp); 478 479 /* reset mcr */ 480 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_MCR, 481 NTWOC_MCR_DTR0 | NTWOC_MCR_DTR1 | NTWOC_MCR_TE0 | NTWOC_MCR_TE1); 482 483 484 /* allow for address above 1M and 16 bit i/o */ 485 #if 0 486 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR, 487 bus_space_read_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR) 488 | NTWOC_PCR_EN_VPM | NTWOC_PCR_ISA16); 489 #endif 490 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR, 491 bus_space_read_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR) 492 | NTWOC_PCR_ISA16); 493 494 /* program the card with the io address */ 495 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR, 496 ((ia->ia_iomem[0].ir_addr >> 16) & NTWOC_PCR_16M_SEL) 497 | 498 (bus_space_read_1(sca->sc_iot, sca->sc_ioh, NTWOC_PCR) 499 & ~NTWOC_PCR_16M_SEL)); 500 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_BAR, 501 (ia->ia_iomem[0].ir_addr >> 12)); 502 503 /* enable the memory window */ 504 ntwoc_isa_set_on(sca); 505 506 /* 507 * write a magic value into each possible page of memory 508 * incrementing by our window size 509 */ 510 addr = 0; 511 for (i = 0; i <= NTWOC_PSR_PG_SEL; addr += sca->scu_pagesize, i++) { 512 /* select the page */ 513 ntwoc_isa_set_page(sca, addr); 514 bus_space_write_2(sca->scu_memt, sca->scu_memh, 0, 0xAA55); 515 } 516 517 /* 518 * go back through pages and verify that value is different 519 * after writing to previous page 520 */ 521 addr = 0; 522 for (i = 0; i <= NTWOC_PSR_PG_SEL; addr += sca->scu_pagesize, i++) { 523 ntwoc_isa_set_page(sca, addr); 524 525 tmp = bus_space_read_2(sca->scu_memt, sca->scu_memh, 0); 526 if (tmp != 0xAA55) 527 break; 528 529 /* write a different value into this page now */ 530 bus_space_write_2(sca->scu_memt, sca->scu_memh, 0, i); 531 } 532 sca->scu_npages = pgs = i; /* final count of 16K pages */ 533 534 /* erase the pages */ 535 addr = 0; 536 for (i = 0; i <= pgs; addr += sca->scu_pagesize, i++) { 537 ntwoc_isa_set_page(sca, addr); 538 bus_space_set_region_1(sca->scu_memt, sca->scu_memh, 0, 0, 539 sca->scu_pagesize); 540 } 541 542 #if 0 543 printf("%s: sca port 0x%x-0x%x dpram %ldk %d serial port%s\n", 544 device_xname(sc->sc_dev), ia->ia_io[0].ir_addr | 0x8000, 545 (ia->ia_io[0].ir_addr | 0x8000) + NTWOC_SRC_ASIC_SIZE - 1, 546 pgs * (sca->scu_pagesize / 1024), sca->sc_numports, 547 (sca->sc_numports > 1 ? "s" : "")); 548 #else 549 printf("%s: dpram %ldk %d serial port%s\n", 550 device_xname(sc->sc_dev), (u_long)pgs * (sca->scu_pagesize / 1024), 551 sca->sc_numports, (sca->sc_numports > 1 ? "s" : "")); 552 #endif 553 554 /* disable the memory window */ 555 ntwoc_isa_set_off(sca); 556 557 /* enabled sca DMA */ 558 bus_space_write_1(sca->sc_iot, sca->sc_ioh, NTWOC_PSR, 559 bus_space_read_1(sca->sc_iot, sca->sc_ioh, NTWOC_PSR) 560 | NTWOC_PSR_EN_SCA_DMA); 561 562 /* now establish our irq -- perhaps sanity check the value */ 563 sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq[0].ir_irq, 564 IST_EDGE, IPL_NET, ntwoc_isa_intr, sc); 565 if (sc->sc_ih == NULL) { 566 aprint_error_dev(sc->sc_dev, "can't establish interrupt\n"); 567 return; 568 } 569 570 /* make sure we have 2 pages for each port */ 571 if (pgs < 2 * sca->sc_numports) { 572 aprint_error_dev(self, 573 "%d less than required pages of memory of %d\n", 574 pgs, 2 * sca->sc_numports); 575 return; 576 } 577 578 /* sca_get_base_clock(sca); */ 579 580 /* 581 * get clock information from user 582 */ 583 rdiv = (flags & NTWOC_FLAGS_RXDIV_MASK) >> NTWOC_FLAGS_RXDIV_SHIFT; 584 if (rdiv > 9) 585 panic("bad rx divisor in flags"); 586 587 tdiv = (flags & NTWOC_FLAGS_TXDIV_MASK) >> NTWOC_FLAGS_TXDIV_SHIFT; 588 if (tdiv > 9) 589 panic("bad tx divisor in flags"); 590 tmc = (flags & NTWOC_FLAGS_TMC_MASK) >> NTWOC_FLAGS_TMC_SHIFT; 591 592 ntwoc_isa_get_clock(&sca->sc_ports[0], 593 flags & NTWOC_FLAGS_CLK0_MASK, tmc, rdiv, tdiv); 594 if (sca->sc_numports > 1) 595 ntwoc_isa_get_clock(&sca->sc_ports[1], 596 (flags & NTWOC_FLAGS_CLK1_MASK) >> NTWOC_FLAGS_CLK1_SHIFT, 597 tmc, rdiv, tdiv); 598 599 ntwoc_isa_setup_memory(sca); 600 601 sca_init(sca); 602 603 /* attach configured ports */ 604 sca_port_attach(sca, 0); 605 if (sca->sc_numports == 2) 606 sca_port_attach(sca, 1); 607 608 /* 609 * Add shutdown hook so that DMA is disabled prior to reboot. Not 610 * doing do could allow DMA to corrupt kernel memory during the 611 * reboot before the driver initializes. 612 */ 613 shutdownhook_establish(ntwoc_isa_shutdown, sc); 614 615 #if __NetBSD_Version__ >= 104160000 616 /* 617 * defer getting the base clock until interrupts are enabled 618 * (and thus we have microtime()) 619 */ 620 config_interrupts(self, ntwoc_isa_config_interrupts); 621 #else 622 /* no callback pre 1.4-mumble */ 623 sca->sc_baseclock = SCA_BASECLOCK; 624 sca_print_clock_info(&sc->sc_sca); 625 #endif 626 } 627 628 /* 629 * extract the clock information for a port from the flags field 630 */ 631 static void 632 ntwoc_isa_get_clock(struct sca_port *scp, u_int8_t flags, u_int8_t tmc, 633 u_int8_t rdiv, u_int8_t tdiv) 634 { 635 scp->sp_eclock = 636 (flags & NTWOC_FLAGS_ECLOCK_MASK) >> NTWOC_FLAGS_ECLOCK_SHIFT; 637 scp->sp_rxs = rdiv; 638 scp->sp_txs = tdiv; 639 scp->sp_tmc = tmc; 640 641 /* get rx source */ 642 switch ((flags & NTWOC_FLAGS_RXS_MASK) >> NTWOC_FLAGS_RXS_SHIFT) { 643 case NTWOC_FLAGS_RXS_LINE: 644 scp->sp_rxs = 0; 645 break; 646 case NTWOC_FLAGS_RXS_LINE_SN: 647 scp->sp_rxs |= SCA_RXS_CLK_LINE_SN; 648 break; 649 case NTWOC_FLAGS_RXS_INTERNAL: 650 scp->sp_rxs |= SCA_RXS_CLK_INTERNAL; 651 break; 652 case NTWOC_FLAGS_RXS_ADPLL_OUT: 653 scp->sp_rxs |= SCA_RXS_CLK_ADPLL_OUT; 654 break; 655 case NTWOC_FLAGS_RXS_ADPLL_IN: 656 scp->sp_rxs |= SCA_RXS_CLK_ADPLL_IN; 657 break; 658 default: 659 panic("bad rx source in flags"); 660 } 661 662 /* get tx source */ 663 switch ((flags & NTWOC_FLAGS_TXS_MASK) >> NTWOC_FLAGS_TXS_SHIFT) { 664 case NTWOC_FLAGS_TXS_LINE: 665 scp->sp_txs = 0; 666 break; 667 case NTWOC_FLAGS_TXS_INTERNAL: 668 scp->sp_txs |= SCA_TXS_CLK_INTERNAL; 669 break; 670 case NTWOC_FLAGS_TXS_RXCLOCK: 671 scp->sp_txs |= SCA_TXS_CLK_RXCLK; 672 break; 673 default: 674 panic("bad rx source in flags"); 675 } 676 } 677 678 679 static int 680 ntwoc_isa_intr(void *arg) 681 { 682 struct ntwoc_isa_softc *sc = (struct ntwoc_isa_softc *)arg; 683 684 return sca_hardintr(&sc->sc_sca); 685 } 686 687 /* 688 * shut down interrupts and DMA, so we don't trash the kernel on warm 689 * boot. Also, lower DTR on each port and disable card interrupts. 690 */ 691 static void 692 ntwoc_isa_shutdown(void *aux) 693 { 694 struct ntwoc_isa_softc *sc = aux; 695 u_int16_t mcr; 696 697 /* 698 * shut down the SCA ports 699 */ 700 sca_shutdown(&sc->sc_sca); 701 702 /* 703 * lower DTR on both ports 704 */ 705 mcr = bus_space_read_1(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh, NTWOC_MCR); 706 mcr |= (NTWOC_MCR_DTR0 | NTWOC_MCR_DTR1); 707 bus_space_write_1(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh, NTWOC_MCR, mcr); 708 709 /* turn off the card */ 710 bus_space_write_1(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh, NTWOC_PCR, 0); 711 } 712 713 static void 714 ntwoc_isa_dtr_callback(void *aux, int port, int state) 715 { 716 struct ntwoc_isa_softc *sc = aux; 717 u_int8_t mcr; 718 719 mcr = bus_space_read_1(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh, NTWOC_MCR); 720 721 NTWO_DPRINTF(("port == %d, state == %d, old mcr: 0x%02x\n", 722 port, state, mcr)); 723 724 if (port == 0) { 725 if (state == 0) 726 mcr |= NTWOC_MCR_DTR0; 727 else 728 mcr &= ~NTWOC_MCR_DTR0; 729 } else { 730 if (state == 0) 731 mcr |= NTWOC_MCR_DTR1; 732 else 733 mcr &= ~NTWOC_MCR_DTR1; 734 } 735 736 NTWO_DPRINTF(("new mcr: 0x%02x\n", mcr)); 737 738 bus_space_write_1(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh, NTWOC_MCR, mcr); 739 } 740 741 static void 742 ntwoc_isa_clock_callback(void *aux, int port, int enable) 743 { 744 struct ntwoc_isa_softc *sc = aux; 745 u_int8_t mcr; 746 747 mcr = bus_space_read_1(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh, NTWOC_MCR); 748 749 NTWO_DPRINTF(("clock: port == %d, enable == %d, old mcr: 0x%02x\n", 750 port, enable, mcr)); 751 752 if (port == 0) { 753 if (enable == 0) 754 mcr &= ~NTWOC_MCR_ETC0; 755 else 756 mcr |= NTWOC_MCR_ETC0; 757 } else { 758 if (enable == 0) 759 mcr &= ~NTWOC_MCR_ETC1; 760 else 761 mcr |= NTWOC_MCR_ETC1; 762 } 763 764 NTWO_DPRINTF(("clock: new mcr: 0x%02x\n", mcr)); 765 766 bus_space_write_1(sc->sc_sca.sc_iot, sc->sc_sca.sc_ioh, NTWOC_MCR, mcr); 767 } 768 769 static void 770 ntwoc_isa_setup_memory(struct sca_softc *sc) 771 { 772 struct sca_port *scp; 773 u_int i, j; 774 775 /* allocate enough descriptors for a full page */ 776 777 sc->sc_ports[0].sp_ntxdesc = (sc->scu_pagesize / SCA_BSIZE) - 1; 778 sc->sc_ports[0].sp_nrxdesc = (sc->scu_pagesize / SCA_BSIZE) - 1; 779 if (sc->sc_numports == 2) { 780 sc->sc_ports[1].sp_ntxdesc = sc->sc_ports[0].sp_ntxdesc; 781 sc->sc_ports[1].sp_nrxdesc = sc->sc_ports[0].sp_nrxdesc; 782 } 783 784 j = 0; 785 for (i = 0; i < sc->sc_numports; i++) { 786 scp = &sc->sc_ports[i]; 787 scp->sp_txdesc_p = (bus_addr_t)(j * sc->scu_pagesize); 788 scp->sp_txdesc = (void *)(uintptr_t)scp->sp_txdesc_p; 789 scp->sp_txbuf_p = scp->sp_txdesc_p; 790 scp->sp_txbuf_p += SCA_BSIZE; 791 scp->sp_txbuf = (void *)(uintptr_t)scp->sp_txbuf_p; 792 j++; 793 794 scp->sp_rxdesc_p = (bus_addr_t)(j * sc->scu_pagesize); 795 scp->sp_rxdesc = (void *)(uintptr_t)scp->sp_txdesc_p; 796 scp->sp_rxbuf_p = scp->sp_rxdesc_p; 797 scp->sp_rxbuf_p += SCA_BSIZE; 798 scp->sp_rxbuf = (void *)(uintptr_t)scp->sp_rxbuf_p; 799 j++; 800 } 801 } 802 803 #if __NetBSD_Version__ >= 104160000 804 /* 805 * get the base clock frequency 806 */ 807 static void 808 ntwoc_isa_config_interrupts(device_t self) 809 { 810 struct ntwoc_isa_softc *sc; 811 812 sc = device_private(self); 813 sca_get_base_clock(&sc->sc_sca); 814 sca_print_clock_info(&sc->sc_sca); 815 } 816 #endif 817
Indexes created Wed Sep 24 15:09:51 GMT 2025