if_ed_cbus.c revision 149558
1/*- 2 * Copyright (c) 1995, David Greenman 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 unmodified, this list of conditions, and the following 10 * disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: head/sys/dev/ed/if_ed_cbus.c 149558 2005-08-28 23:56:25Z imp $ 28 */ 29 30#include <sys/param.h> 31#include <sys/systm.h> 32#include <sys/socket.h> 33#include <sys/kernel.h> 34 35#include <sys/module.h> 36#include <sys/bus.h> 37#include <machine/bus.h> 38#include <sys/rman.h> 39#include <machine/resource.h> 40#include <machine/clock.h> 41 42#include <net/ethernet.h> 43#include <net/if.h> 44#include <net/if_arp.h> 45#include <net/if_mib.h> 46 47#include <isa/isavar.h> 48 49#include <dev/ed/if_edvar.h> 50#include <dev/ed/if_edreg.h> 51#include <dev/ed/if_ed98.h> 52 53static int ed98_alloc_port(device_t, int); 54static int ed98_alloc_memory(device_t, int); 55static int ed_pio_testmem(struct ed_softc *, int, int, int); 56static int ed_probe_SIC98(device_t, int, int); 57static int ed_probe_CNET98(device_t, int, int); 58static int ed_probe_CNET98EL(device_t, int, int); 59static int ed_probe_NEC77(device_t, int, int); 60static int ed_probe_NW98X(device_t, int, int); 61static int ed_probe_SB98(device_t, int, int); 62static int ed_probe_EZ98(device_t, int, int); 63static int ed98_probe_Novell(device_t, int, int); 64static int ed98_probe_generic8390(struct ed_softc *); 65static void ed_reset_CNET98(struct ed_softc *, int); 66static void ed_winsel_CNET98(struct ed_softc *, u_short); 67static void ed_get_SB98(struct ed_softc *); 68 69static int ed_cbus_probe(device_t); 70static int ed_cbus_attach(device_t); 71 72static struct isa_pnp_id ed_ids[] = { 73/* TODO - list up PnP boards for PC-98 */ 74 { 0, NULL } 75}; 76 77static int 78ed_cbus_probe(device_t dev) 79{ 80 struct ed_softc *sc = device_get_softc(dev); 81 int flags = device_get_flags(dev); 82 int error = 0; 83 84 sc->type = ED_TYPE98(flags); 85#ifdef ED_DEBUG 86 device_printf(dev, "ed_cbus_probe: sc->type=%x\n", sc->type); 87#endif 88 89 /* Check isapnp ids */ 90 error = ISA_PNP_PROBE(device_get_parent(dev), dev, ed_ids); 91#ifdef ED_DEBUG 92 device_printf(dev, "ed_cbus_probe: ISA_PNP_PROBE returns %d\n", error); 93#endif 94 95 /* If the card had a PnP ID that didn't match any we know about */ 96 if (error == ENXIO) 97 goto end; 98 99 /* If we had some other problem. */ 100 if (!(error == 0 || error == ENOENT)) 101 goto end; 102 103 /* Heuristic probes */ 104#ifdef ED_DEBUG 105 device_printf(dev, "ed_cbus_probe: Heuristic probes start\n"); 106#endif 107 switch (sc->type) { 108 case ED_TYPE98_GENERIC: 109 /* 110 * CAUTION! 111 * sc->type of these boards are overwritten by PC/AT's value. 112 */ 113 114 /* 115 * SMC EtherEZ98 116 */ 117 error = ed_probe_EZ98(dev, 0, flags); 118 if (error == 0) 119 goto end; 120 121 ed_release_resources(dev); 122 123 /* 124 * Allied Telesis CenterCom LA-98-T 125 */ 126 error = ed_probe_Novell(dev, 0, flags); 127 if (error == 0) { 128 ed_Novell_read_mac(sc); 129 goto end; 130 } 131 break; 132 133 /* 134 * NE2000-like boards probe routine 135 */ 136 case ED_TYPE98_BDN: 137 /* 138 * ELECOM LANEED LD-BDN 139 * PLANET SMART COM 98 EN-2298 140 */ 141 case ED_TYPE98_LGY: 142 /* 143 * MELCO LGY-98, IND-SP, IND-SS 144 * MACNICA NE2098 145 */ 146 case ED_TYPE98_ICM: 147 /* 148 * ICM DT-ET-25, DT-ET-T5, IF-2766ET, IF-2771ET 149 * D-Link DE-298P, DE-298 150 */ 151 case ED_TYPE98_EGY: 152 /* 153 * MELCO EGY-98 154 * Contec C-NET(98)E-A, C-NET(98)L-A 155 */ 156 case ED_TYPE98_108: 157 /* 158 * NEC PC-9801-107,108 159 */ 160 case ED_TYPE98_NC5098: 161 /* 162 * NextCom NC5098 163 */ 164 error = ed98_probe_Novell(dev, 0, flags); 165 break; 166 167 /* 168 * other boards with special probe routine 169 */ 170 case ED_TYPE98_SIC: 171 /* 172 * Allied Telesis SIC-98 173 */ 174 error = ed_probe_SIC98(dev, 0, flags); 175 break; 176 177 case ED_TYPE98_CNET98EL: 178 /* 179 * Contec C-NET(98)E/L 180 */ 181 error = ed_probe_CNET98EL(dev, 0, flags); 182 break; 183 184 case ED_TYPE98_CNET98: 185 /* 186 * Contec C-NET(98) 187 */ 188 error = ed_probe_CNET98(dev, 0, flags); 189 break; 190 191 case ED_TYPE98_LA98: 192 /* 193 * IO-DATA LA/T-98 194 * NEC PC-9801-77,78 195 */ 196 error = ed_probe_NEC77(dev, 0, flags); 197 break; 198 199 case ED_TYPE98_NW98X: 200 /* 201 * Networld EC/EP-98X 202 */ 203 error = ed_probe_NW98X(dev, 0, flags); 204 break; 205 206 case ED_TYPE98_SB98: 207 /* 208 * Soliton SB-9801 209 * Fujikura FN-9801 210 */ 211 error = ed_probe_SB98(dev, 0, flags); 212 break; 213 } 214 215end: 216#ifdef ED_DEBUG 217 device_printf(dev, "ed_cbus_probe: end, error=%d\n", error); 218#endif 219 if (error == 0) 220 error = ed_alloc_irq(dev, 0, 0); 221 222 ed_release_resources(dev); 223 return (error); 224} 225 226static int 227ed_cbus_attach(dev) 228 device_t dev; 229{ 230 struct ed_softc *sc = device_get_softc(dev); 231 int flags = device_get_flags(dev); 232 int error; 233 234 if (sc->port_used > 0) { 235 if (ED_TYPE98(flags) == ED_TYPE98_GENERIC) 236 ed_alloc_port(dev, sc->port_rid, sc->port_used); 237 else 238 ed98_alloc_port(dev, sc->port_rid); 239 } 240 if (sc->mem_used) 241 ed_alloc_memory(dev, sc->mem_rid, sc->mem_used); 242 243 ed_alloc_irq(dev, sc->irq_rid, 0); 244 245 error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_NET | INTR_MPSAFE, 246 edintr, sc, &sc->irq_handle); 247 if (error) { 248 ed_release_resources(dev); 249 return (error); 250 } 251 252 return ed_attach(dev); 253} 254 255/* 256 * Interrupt conversion table for EtherEZ98 257 */ 258static uint16_t ed_EZ98_intr_val[] = { 259 0, 260 3, 261 5, 262 6, 263 0, 264 9, 265 12, 266 13 267}; 268 269static int 270ed_probe_EZ98(device_t dev, int port_rid, int flags) 271{ 272 struct ed_softc *sc = device_get_softc(dev); 273 int error; 274 static unsigned short *intr_vals[] = {NULL, ed_EZ98_intr_val}; 275 276 error = ed_alloc_port(dev, port_rid, ED_EZ98_IO_PORTS); 277 if (error) { 278 return (error); 279 } 280 281 sc->asic_offset = ED_EZ98_ASIC_OFFSET; 282 sc->nic_offset = ED_EZ98_NIC_OFFSET; 283 284 return ed_probe_WD80x3_generic(dev, flags, intr_vals); 285} 286 287/* 288 * I/O conversion tables 289 */ 290 291/* LGY-98, ICM, C-NET(98)E/L */ 292static bus_addr_t ed98_ioaddr_generic[] = { 293 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 294}; 295 296/* 297 * Definitions for Contec C-NET(98)E/L 298 */ 299#define ED_CNET98EL_ICR 2 /* Interrupt Configuration Register */ 300 301#define ED_CNET98EL_ICR_IRQ3 0x01 302#define ED_CNET98EL_ICR_IRQ5 0x02 303#define ED_CNET98EL_ICR_IRQ6 0x04 304#define ED_CNET98EL_ICR_IRQ12 0x20 305 306#define ED_CNET98EL_IMR 4 /* Interrupt Mask Register */ 307#define ED_CNET98EL_ISR 5 /* Interrupt Status Register */ 308 309/* EGY-98 */ 310static bus_addr_t ed98_ioaddr_egy98[] = { 311 0, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 312 0x100, 0x102, 0x104, 0x106, 0x108, 0x10a, 0x10c, 0x10e 313}; 314 315/* SIC-98 */ 316static bus_addr_t ed98_ioaddr_sic98[] = { 317 0x0000, 0x0200, 0x0400, 0x0600, 0x0800, 0x0a00, 0x0c00, 0x0e00, 318 0x1000, 0x1200, 0x1400, 0x1600, 0x1800, 0x1a00, 0x1c00, 0x1e00 319}; 320 321/* LA/T-98, LD-BDN, PC-9801-77, SB-9801 */ 322static bus_addr_t ed98_ioaddr_la98[] = { 323 0x0000, 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000, 324 0x8000, 0x9000, 0xa000, 0xb000, 0xc000, 0xd000, 0xe000, 0xf000, 325 0x0100 /* for NEC 77(see below) */ 326}; 327 328/* 329 * Definitions for NEC PC-9801-77 330 */ 331#define ED_NEC77_IRQ 16 /* Interrupt Configuration Register */ 332 333#define ED_NEC77_IRQ3 0x04 334#define ED_NEC77_IRQ5 0x06 335#define ED_NEC77_IRQ6 0x08 336#define ED_NEC77_IRQ12 0x0a 337#define ED_NEC77_IRQ13 0x02 338 339/* 340 * Definitions for Soliton SB-9801 341 */ 342#define ED_SB98_CFG 1 /* Board configuration */ 343 344#define ED_SB98_CFG_IRQ3 0x00 345#define ED_SB98_CFG_IRQ5 0x04 346#define ED_SB98_CFG_IRQ6 0x08 347#define ED_SB98_CFG_IRQ12 0x0c 348#define ED_SB98_CFG_ALTPORT 0x40 /* use EXTERNAL media */ 349#define ED_SB98_CFG_ENABLE 0xa0 /* enable configuration */ 350 351#define ED_SB98_EEPENA 2 /* EEPROM access enable */ 352 353#define ED_SB98_EEPENA_DISABLE 0x00 354#define ED_SB98_EEPENA_ENABLE 0x01 355 356#define ED_SB98_EEP 3 /* EEPROM access */ 357 358#define ED_SB98_EEP_SDA 0x01 /* Serial Data */ 359#define ED_SB98_EEP_SCL 0x02 /* Serial Clock */ 360#define ED_SB98_EEP_READ 0x01 /* Read Command */ 361 362#define ED_SB98_EEP_DELAY 300 363 364#define ED_SB98_ADDRESS 0x01 /* Station Address(1-6) */ 365 366#define ED_SB98_POLARITY 4 /* Polarity */ 367 368/* PC-9801-108 */ 369static bus_addr_t ed98_ioaddr_nec108[] = { 370 0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000a, 0x000c, 0x000e, 371 0x1000, 0x1002, 0x1004, 0x1006, 0x1008, 0x100a, 0x100c, 0x100e 372}; 373 374/* C-NET(98) */ 375static bus_addr_t ed98_ioaddr_cnet98[] = { 376 0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000a, 0x000c, 0x000e, 377 0x0400, 0x0402, 0x0404, 0x0406, 0x0408, 0x040a, 0x040c, 0x040e 378}; 379 380/* 381 * Definitions for Contec C-NET(98) 382 */ 383#define ED_CNET98_MAP_REG0L 0 /* MAPPING register0 Low */ 384#define ED_CNET98_MAP_REG1L 1 /* MAPPING register1 Low */ 385#define ED_CNET98_MAP_REG2L 2 /* MAPPING register2 Low */ 386#define ED_CNET98_MAP_REG3L 3 /* MAPPING register3 Low */ 387#define ED_CNET98_MAP_REG0H 4 /* MAPPING register0 Hi */ 388#define ED_CNET98_MAP_REG1H 5 /* MAPPING register1 Hi */ 389#define ED_CNET98_MAP_REG2H 6 /* MAPPING register2 Hi */ 390#define ED_CNET98_MAP_REG3H 7 /* MAPPING register3 Hi */ 391#define ED_CNET98_WIN_REG 8 /* Window register */ 392#define ED_CNET98_INT_LEV 9 /* Init level register */ 393 394#define ED_CNET98_INT_IRQ3 0x01 /* INT 0 */ 395#define ED_CNET98_INT_IRQ5 0x02 /* INT 1 */ 396#define ED_CNET98_INT_IRQ6 0x04 /* INT 2 */ 397#define ED_CNET98_INT_IRQ9 0x08 /* INT 3 */ 398#define ED_CNET98_INT_IRQ12 0x20 /* INT 5 */ 399#define ED_CNET98_INT_IRQ13 0x40 /* INT 6 */ 400 401#define ED_CNET98_INT_REQ 10 /* Init request register */ 402#define ED_CNET98_INT_MASK 11 /* Init mask register */ 403#define ED_CNET98_INT_STAT 12 /* Init status register */ 404#define ED_CNET98_INT_CLR 12 /* Init clear register */ 405#define ED_CNET98_RESERVE1 13 406#define ED_CNET98_RESERVE2 14 407#define ED_CNET98_RESERVE3 15 408 409/* EC/EP-98X, NC5098 */ 410static bus_addr_t ed98_ioaddr_nw98x[] = { 411 0x0000, 0x0100, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600, 0x0700, 412 0x0800, 0x0900, 0x0a00, 0x0b00, 0x0c00, 0x0d00, 0x0e00, 0x0f00, 413 0x1000 /* for EC/EP-98X(see below) */ 414}; 415 416/* 417 * Definitions for Networld EC/EP-98X 418 */ 419#define ED_NW98X_IRQ 16 /* Interrupt Configuration Register */ 420 421#define ED_NW98X_IRQ3 0x04 422#define ED_NW98X_IRQ5 0x06 423#define ED_NW98X_IRQ6 0x08 424#define ED_NW98X_IRQ12 0x0a 425#define ED_NW98X_IRQ13 0x02 426 427/* NC5098 ASIC */ 428static bus_addr_t ed98_asic_nc5098[] = { 429/* DATA ENADDR RESET */ 430 0x0000, 0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x4000, 431 0, 0, 0, 0, 0, 0, 0, 0 432}; 433 434/* 435 * Definitions for NextCom NC5098 436 */ 437#define ED_NC5098_ENADDR 1 /* Station Address(1-6) */ 438 439/* 440 * Allocate a port resource with the given resource id. 441 */ 442static int 443ed98_alloc_port(device_t dev, int rid) 444{ 445 struct ed_softc *sc = device_get_softc(dev); 446 struct resource *res; 447 int error; 448 bus_addr_t *io_nic, *io_asic, adj; 449 static bus_addr_t io_res[ED_NOVELL_IO_PORTS + 1]; 450 int i, n; 451 int offset, reset, data; 452 453 /* Set i/o table for resource manager */ 454 io_nic = io_asic = ed98_ioaddr_generic; 455 offset = ED_NOVELL_ASIC_OFFSET; 456 reset = ED_NOVELL_RESET; 457 data = ED_NOVELL_DATA; 458 n = ED_NOVELL_IO_PORTS; 459 460 switch (sc->type) { 461 case ED_TYPE98_LGY: 462 io_asic = ed98_ioaddr_egy98; /* XXX - Yes, we use egy98 */ 463 offset = 0x0200; 464 reset = 8; 465 break; 466 467 case ED_TYPE98_EGY: 468 io_nic = io_asic = ed98_ioaddr_egy98; 469 offset = 0x0200; 470 reset = 8; 471 break; 472 473 case ED_TYPE98_ICM: 474 offset = 0x0100; 475 break; 476 477 case ED_TYPE98_BDN: 478 io_nic = io_asic = ed98_ioaddr_la98; 479 offset = 0x0100; 480 reset = 0x0c; 481 break; 482 483 case ED_TYPE98_SIC: 484 io_nic = io_asic = ed98_ioaddr_sic98; 485 offset = 0x2000; 486 n = 16+1; 487 break; 488 489 case ED_TYPE98_108: 490 io_nic = io_asic = ed98_ioaddr_nec108; 491 offset = 0x0888; /* XXX - overwritten after */ 492 reset = 1; 493 n = 16; /* XXX - does not set ASIC i/o here */ 494 break; 495 496 case ED_TYPE98_LA98: 497 io_nic = io_asic = ed98_ioaddr_la98; 498 offset = 0x0100; 499 break; 500 501 case ED_TYPE98_CNET98EL: 502 offset = 0x0400; 503 data = 0x0e; 504 break; 505 506 case ED_TYPE98_CNET98: 507 /* XXX - Yes, we use generic i/o here */ 508 offset = 0x0400; 509 break; 510 511 case ED_TYPE98_NW98X: 512 io_nic = io_asic = ed98_ioaddr_nw98x; 513 offset = 0x1000; 514 break; 515 516 case ED_TYPE98_SB98: 517 io_nic = io_asic = ed98_ioaddr_la98; 518 offset = 0x0400; 519 reset = 7; 520 break; 521 522 case ED_TYPE98_NC5098: 523 io_nic = ed98_ioaddr_nw98x; 524 io_asic = ed98_asic_nc5098; 525 offset = 0x2000; 526 reset = 7; 527 n = 16+8; /* XXX */ 528 break; 529 } 530 531 bcopy(io_nic, io_res, sizeof(io_nic[0]) * ED_NOVELL_ASIC_OFFSET); 532 for (i = ED_NOVELL_ASIC_OFFSET; i < ED_NOVELL_IO_PORTS; i++) 533 io_res[i] = io_asic[i - ED_NOVELL_ASIC_OFFSET] + offset; 534 535 res = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &rid, io_res, n, 536 RF_ACTIVE); 537 if (!res) 538 return (ENOENT); 539 540 sc->port_rid = rid; 541 sc->port_res = res; 542 sc->port_used = n; 543 544 /* Re-map i/o table if needed */ 545 switch (sc->type) { 546 case ED_TYPE98_LA98: 547 case ED_TYPE98_NW98X: 548 io_res[n] = io_asic[n - ED_NOVELL_ASIC_OFFSET] + offset; 549 n++; 550 break; 551 552 case ED_TYPE98_108: 553 adj = (rman_get_start(res) & 0xf000) / 2; 554 offset = (offset | adj) - rman_get_start(res); 555 556 for (n = ED_NOVELL_ASIC_OFFSET; n < ED_NOVELL_IO_PORTS; n++) 557 io_res[n] = io_asic[n - ED_NOVELL_ASIC_OFFSET] + offset; 558 break; 559 560 case ED_TYPE98_CNET98: 561 io_nic = io_asic = ed98_ioaddr_cnet98; 562 offset = 1; 563 564 bcopy(io_nic, io_res, sizeof(io_nic[0]) * ED_NOVELL_ASIC_OFFSET); 565 for (n = ED_NOVELL_ASIC_OFFSET; n < ED_NOVELL_IO_PORTS; n++) 566 io_res[n] = io_asic[n - ED_NOVELL_ASIC_OFFSET] + offset; 567 break; 568 569 case ED_TYPE98_NC5098: 570 n = ED_NOVELL_IO_PORTS; 571 break; 572 } 573 574 if (reset != ED_NOVELL_RESET) 575 io_res[ED_NOVELL_ASIC_OFFSET + ED_NOVELL_RESET] = 576 io_res[ED_NOVELL_ASIC_OFFSET + reset]; 577 if (data != ED_NOVELL_DATA) { 578 io_res[ED_NOVELL_ASIC_OFFSET + ED_NOVELL_DATA] = 579 io_res[ED_NOVELL_ASIC_OFFSET + data]; 580#if 0 581 io_res[ED_NOVELL_ASIC_OFFSET + ED_NOVELL_DATA + 1] = 582 io_res[ED_NOVELL_ASIC_OFFSET + data + 1]; 583#endif 584 } 585 586 error = isa_load_resourcev(res, io_res, n); 587 if (error != 0) 588 return (ENOENT); 589#ifdef ED_DEBUG 590 device_printf(dev, "ed98_alloc_port: i/o ports = %d\n", n); 591 for (i = 0; i < n; i++) 592 printf("%x,", io_res[i]); 593 printf("\n"); 594#endif 595 return (0); 596} 597 598static int 599ed98_alloc_memory(dev, rid) 600 device_t dev; 601 int rid; 602{ 603 struct ed_softc *sc = device_get_softc(dev); 604 int error; 605 u_long conf_maddr, conf_msize; 606 607 error = bus_get_resource(dev, SYS_RES_MEMORY, 0, &conf_maddr, 608 &conf_msize); 609 if (error) 610 return (error); 611 612 if ((conf_maddr == 0) || (conf_msize == 0)) 613 return (ENXIO); 614 615 error = ed_alloc_memory(dev, rid, (int) conf_msize); 616 if (error) 617 return (error); 618 619 sc->mem_start = 0; 620 sc->mem_size = conf_msize; 621 622 return (0); 623} 624 625/* 626 * Generic probe routine for testing for the existance of a DS8390. 627 * Must be called after the NIC has just been reset. This routine 628 * works by looking at certain register values that are guaranteed 629 * to be initialized a certain way after power-up or reset. Seems 630 * not to currently work on the 83C690. 631 * 632 * Specifically: 633 * 634 * Register reset bits set bits 635 * Command Register (CR) TXP, STA RD2, STP 636 * Interrupt Status (ISR) RST 637 * Interrupt Mask (IMR) All bits 638 * Data Control (DCR) LAS 639 * Transmit Config. (TCR) LB1, LB0 640 * 641 * XXX - We only check the CR register. 642 * 643 * Return 1 if 8390 was found, 0 if not. 644 */ 645 646static int 647ed98_probe_generic8390(struct ed_softc *sc) 648{ 649 u_char tmp = ed_nic_inb(sc, ED_P0_CR); 650#ifdef DIAGNOSTIC 651 printf("ed?: inb(ED_P0_CR)=%x\n", tmp); 652#endif 653 if ((tmp & (ED_CR_RD2 | ED_CR_TXP | ED_CR_STA | ED_CR_STP)) != 654 (ED_CR_RD2 | ED_CR_STP)) 655 return (0); 656 657 (void) ed_nic_inb(sc, ED_P0_ISR); 658 659 return (1); 660} 661 662static int 663ed98_probe_Novell(device_t dev, int port_rid, int flags) 664{ 665 struct ed_softc *sc = device_get_softc(dev); 666 int error; 667 int n; 668 u_char romdata[ETHER_ADDR_LEN * 2], tmp; 669 670#ifdef ED_DEBUG 671 device_printf(dev, "ed98_probe_Novell: start\n"); 672#endif 673 error = ed98_alloc_port(dev, port_rid); 674 if (error) 675 return (error); 676 677 sc->asic_offset = ED_NOVELL_ASIC_OFFSET; 678 sc->nic_offset = ED_NOVELL_NIC_OFFSET; 679 680 /* Reset the board */ 681#ifdef ED_DEBUG 682 device_printf(dev, "ed98_probe_Novell: reset\n"); 683#endif 684 switch (sc->type) { 685#if 1 /* XXX - I'm not sure this is really necessary... */ 686 case ED_TYPE98_BDN: 687 tmp = ed_asic_inb(sc, ED_NOVELL_RESET); 688 ed_asic_outb(sc, ED_NOVELL_RESET, (tmp & 0xf0) | 0x08); 689 ed_nic_outb(sc, 0x04, tmp); 690 (void) ed_asic_inb(sc, 0x08); 691 ed_asic_outb(sc, 0x08, tmp); 692 ed_asic_outb(sc, 0x08, tmp & 0x7f); 693 break; 694#endif 695 case ED_TYPE98_NC5098: 696 ed_asic_outb(sc, ED_NOVELL_RESET, 0x00); 697 DELAY(5000); 698 ed_asic_outb(sc, ED_NOVELL_RESET, 0x01); 699 break; 700 701 default: 702 tmp = ed_asic_inb(sc, ED_NOVELL_RESET); 703 704 /* 705 * I don't know if this is necessary; probably cruft leftover from 706 * Clarkson packet driver code. Doesn't do a thing on the boards I've 707 * tested. -DG [note that an outb(0x84, 0) seems to work here, and is 708 * non-invasive...but some boards don't seem to reset and I don't have 709 * complete documentation on what the 'right' thing to do is...so we 710 * do the invasive thing for now. Yuck.] 711 */ 712 ed_asic_outb(sc, ED_NOVELL_RESET, tmp); 713 break; 714 } 715 DELAY(5000); 716 717 /* 718 * This is needed because some NE clones apparently don't reset the 719 * NIC properly (or the NIC chip doesn't reset fully on power-up) XXX 720 * - this makes the probe invasive! ...Done against my better 721 * judgement. -DLG 722 */ 723 ed_nic_outb(sc, ED_P0_CR, ED_CR_RD2 | ED_CR_STP); 724 DELAY(5000); 725 726 /* Make sure that we really have an 8390 based board */ 727 if (!ed98_probe_generic8390(sc)) 728 return (ENXIO); 729 730 /* Test memory via PIO */ 731#ifdef ED_DEBUG 732 device_printf(dev, "ed98_probe_Novell: test memory\n"); 733#endif 734 sc->cr_proto = ED_CR_RD2; 735 if (!ed_pio_testmem(sc, 8192, 0, flags) && 736 !ed_pio_testmem(sc, 16384, 1, flags)) 737 return (ENXIO); 738 739 /* Setup the board type */ 740#ifdef ED_DEBUG 741 device_printf(dev, "ed98_probe_Novell: board type\n"); 742#endif 743 switch (sc->type) { 744 case ED_TYPE98_BDN: 745 sc->type_str = "LD-BDN"; 746 break; 747 case ED_TYPE98_EGY: 748 sc->type_str = "EGY-98"; 749 break; 750 case ED_TYPE98_LGY: 751 sc->type_str = "LGY-98"; 752 break; 753 case ED_TYPE98_ICM: 754 sc->type_str = "ICM"; 755 break; 756 case ED_TYPE98_108: 757 sc->type_str = "PC-9801-108"; 758 break; 759 case ED_TYPE98_LA98: 760 sc->type_str = "LA-98"; 761 break; 762 case ED_TYPE98_NW98X: 763 sc->type_str = "NW98X"; 764 break; 765 case ED_TYPE98_NC5098: 766 sc->type_str = "NC5098"; 767 break; 768 default: 769 sc->type_str = NULL; 770 break; 771 } 772 773 /* Get station address */ 774 switch (sc->type) { 775 case ED_TYPE98_NC5098: 776 for (n = 0; n < ETHER_ADDR_LEN; n++) 777 sc->enaddr[n] = ed_asic_inb(sc, ED_NC5098_ENADDR + n); 778 break; 779 780 default: 781 ed_pio_readmem(sc, 0, romdata, sizeof(romdata)); 782 for (n = 0; n < ETHER_ADDR_LEN; n++) 783 sc->enaddr[n] = romdata[n * (sc->isa16bit + 1)]; 784 break; 785 } 786 787 /* clear any pending interrupts that might have occurred above */ 788 ed_nic_outb(sc, ED_P0_ISR, 0xff); 789 790 return (0); 791} 792 793/* 794 * Probe and vendor-specific initialization routine for SIC-98 boards 795 */ 796static int 797ed_probe_SIC98(device_t dev, int port_rid, int flags) 798{ 799 struct ed_softc *sc = device_get_softc(dev); 800 int error; 801 int i; 802 u_char sum; 803 804 /* 805 * Setup card RAM and I/O address 806 * Kernel Virtual to segment C0000-DFFFF???? 807 */ 808 error = ed98_alloc_port(dev, port_rid); 809 if (error) 810 return (error); 811 812 sc->asic_offset = ED_SIC_ASIC_OFFSET; 813 sc->nic_offset = ED_SIC_NIC_OFFSET; 814 815 error = ed98_alloc_memory(dev, 0); 816 if (error) 817 return (error); 818 819 /* Reset card to force it into a known state. */ 820 ed_asic_outb(sc, 0, 0x00); 821 DELAY(100); 822 if (ED_TYPE98SUB(flags) == 0) { 823 /* SIC-98/SIU-98 */ 824 ed_asic_outb(sc, 0, 0x94); 825 DELAY(100); 826 ed_asic_outb(sc, 0, 0x94); 827 } else { 828 /* SIU-98-D */ 829 ed_asic_outb(sc, 0, 0x80); 830 DELAY(100); 831 ed_asic_outb(sc, 0, 0x94); 832 DELAY(100); 833 ed_asic_outb(sc, 0, 0x9e); 834 } 835 DELAY(100); 836 837 /* 838 * Here we check the card ROM, if the checksum passes, and the 839 * type code and ethernet address check out, then we know we have 840 * an SIC card. 841 */ 842 sum = bus_space_read_1(sc->mem_bst, sc->mem_bsh, 6 * 2); 843 for (i = 0; i < ETHER_ADDR_LEN; i++) 844 sum ^= (sc->enaddr[i] = 845 bus_space_read_1(sc->mem_bst, sc->mem_bsh, i * 2)); 846#ifdef ED_DEBUG 847 device_printf(dev, "ed_probe_sic98: got address %6D\n", 848 sc->enaddr, ":"); 849#endif 850 if (sum != 0) 851 return (ENXIO); 852 if ((sc->enaddr[0] | sc->enaddr[1] | sc->enaddr[2]) == 0) 853 return (ENXIO); 854 855 sc->vendor = ED_VENDOR_SIC; 856 sc->type_str = "SIC98"; 857 sc->isa16bit = 1; 858 sc->cr_proto = 0; 859 860 /* 861 * SIC RAM page 0x0000-0x3fff(or 0x7fff) 862 */ 863 if (ED_TYPE98SUB(flags) == 0) 864 ed_asic_outb(sc, 0, 0x90); 865 else 866 ed_asic_outb(sc, 0, 0x8e); 867 DELAY(100); 868 869 error = ed_clear_memory(dev); 870 if (error) 871 return (error); 872 873 sc->mem_shared = 1; 874 sc->mem_end = sc->mem_start + sc->mem_size; 875 876 /* 877 * allocate one xmit buffer if < 16k, two buffers otherwise 878 */ 879 if ((sc->mem_size < 16384) || (flags & ED_FLAGS_NO_MULTI_BUFFERING)) 880 sc->txb_cnt = 1; 881 else 882 sc->txb_cnt = 2; 883 sc->tx_page_start = 0; 884 885 sc->rec_page_start = sc->tx_page_start + ED_TXBUF_SIZE * sc->txb_cnt; 886 sc->rec_page_stop = sc->tx_page_start + sc->mem_size / ED_PAGE_SIZE; 887 888 sc->mem_ring = sc->mem_start + sc->txb_cnt * ED_PAGE_SIZE * ED_TXBUF_SIZE; 889 890 return (0); 891} 892 893/* 894 * Contec C-NET(98) series support routines 895 */ 896static void 897ed_reset_CNET98(struct ed_softc *sc, int flags) 898{ 899 u_int init_addr = ED_CNET98_INIT; 900 u_char tmp; 901 902 /* Choose initial register address */ 903 if (ED_TYPE98SUB(flags) != 0) { 904 init_addr = ED_CNET98_INIT2; 905 } 906#ifdef ED_DEBUG 907 printf("ed?: initial register=%x\n", init_addr); 908#endif 909 /* 910 * Reset the board to force it into a known state. 911 */ 912 outb(init_addr, 0x00); /* request */ 913 DELAY(5000); 914 outb(init_addr, 0x01); /* cancel */ 915 DELAY(5000); 916 917 /* 918 * Set I/O address(A15-12) and cpu type 919 * 920 * AAAAIXXC(8bit) 921 * AAAA: A15-A12, I: I/O enable, XX: reserved, C: CPU type 922 * 923 * CPU type is 1:80286 or higher, 0:not. 924 * But FreeBSD runs under i386 or higher, thus it must be 1. 925 */ 926 tmp = (rman_get_start(sc->port_res) & 0xf000) >> 8; 927 tmp |= (0x08 | 0x01); 928#ifdef ED_DEBUG 929 printf("ed?: outb(%x, %x)\n", init_addr + 2, tmp); 930#endif 931 outb(init_addr + 2, tmp); 932 DELAY(5000); 933 934 /* 935 * This is needed because some NE clones apparently don't reset the 936 * NIC properly (or the NIC chip doesn't reset fully on power-up) XXX 937 * - this makes the probe invasive! ...Done against my better 938 * judgement. -DLG 939 */ 940 ed_nic_outb(sc, ED_P0_CR, ED_CR_RD2 | ED_CR_STP); 941 DELAY(5000); 942} 943 944static void 945ed_winsel_CNET98(struct ed_softc *sc, u_short bank) 946{ 947 u_char mem = (rman_get_start(sc->mem_res) >> 12) & 0xff; 948 949 /* 950 * Disable window memory 951 * bit7 is 0:disable 952 */ 953 ed_asic_outb(sc, ED_CNET98_WIN_REG, mem & 0x7f); 954 DELAY(10); 955 956 /* 957 * Select window address 958 * FreeBSD address 0xf00xxxxx 959 */ 960 ed_asic_outb(sc, ED_CNET98_MAP_REG0L, bank & 0xff); 961 DELAY(10); 962 ed_asic_outb(sc, ED_CNET98_MAP_REG0H, (bank >> 8) & 0xff); 963 DELAY(10); 964 ed_asic_outb(sc, ED_CNET98_MAP_REG1L, 0x00); 965 DELAY(10); 966 ed_asic_outb(sc, ED_CNET98_MAP_REG1H, 0x41); 967 DELAY(10); 968 ed_asic_outb(sc, ED_CNET98_MAP_REG2L, 0x00); 969 DELAY(10); 970 ed_asic_outb(sc, ED_CNET98_MAP_REG2H, 0x42); 971 DELAY(10); 972 ed_asic_outb(sc, ED_CNET98_MAP_REG3L, 0x00); 973 DELAY(10); 974 ed_asic_outb(sc, ED_CNET98_MAP_REG3H, 0x43); 975 DELAY(10); 976 977 /* 978 * Enable window memory(16Kbyte) 979 * bit7 is 1:enable 980 */ 981#ifdef ED_DEBUG 982 printf("ed?: window start address=%x\n", mem); 983#endif 984 ed_asic_outb(sc, ED_CNET98_WIN_REG, mem); 985 DELAY(10); 986} 987 988/* 989 * Probe and vendor-specific initialization routine for C-NET(98) boards 990 */ 991static int 992ed_probe_CNET98(device_t dev, int port_rid, int flags) 993{ 994 struct ed_softc *sc = device_get_softc(dev); 995 int error; 996 u_char tmp; 997 u_long conf_irq, junk; 998#ifdef DIAGNOSTIC 999 u_char tmp_s; 1000#endif 1001 1002 error = ed98_alloc_port(dev, port_rid); 1003 if (error) 1004 return (error); 1005 1006 sc->asic_offset = ED_NOVELL_ASIC_OFFSET; 1007 sc->nic_offset = ED_NOVELL_NIC_OFFSET; 1008 1009 error = ed98_alloc_memory(dev, 0); 1010 if (error) 1011 return (error); 1012 1013 /* Check I/O address. 0x[a-f]3d0 are allowed. */ 1014 if (((rman_get_start(sc->port_res) & 0x0fff) != 0x03d0) 1015 || ((rman_get_start(sc->port_res) & 0xf000) < (u_short) 0xa000)) { 1016#ifdef DIAGNOSTIC 1017 device_printf(dev, "Invalid i/o port configuration (0x%lx) " 1018 "must be %s for %s\n", rman_get_start(sc->port_res), 1019 "0x[a-f]3d0", "CNET98"); 1020#endif 1021 return (ENXIO); 1022 } 1023 1024#ifdef DIAGNOSTIC 1025 /* Check window area address */ 1026 tmp_s = rman_get_start(sc->mem_res) >> 12; 1027 if (tmp_s < 0x80) { 1028 device_printf(dev, "Please change window address(0x%lx)\n", 1029 rman_get_start(sc->mem_res)); 1030 return (ENXIO); 1031 } 1032 1033 tmp_s &= 0x0f; 1034 tmp = rman_get_start(sc->port_res) >> 12; 1035 if ((tmp_s <= tmp) && (tmp < (tmp_s + 4))) { 1036 device_printf(dev, "Please change iobase address(0x%lx) " 1037 "or window address(0x%lx)\n", 1038 rman_get_start(sc->port_res), 1039 rman_get_start(sc->mem_res)); 1040 return (ENXIO); 1041 } 1042#endif 1043 /* Reset the board */ 1044 ed_reset_CNET98(sc, flags); 1045 1046 /* 1047 * This is needed because some NE clones apparently don't reset the 1048 * NIC properly (or the NIC chip doesn't reset fully on power-up) XXX 1049 * - this makes the probe invasive! ...Done against my better 1050 * judgement. -DLG 1051 */ 1052 ed_nic_outb(sc, ED_P0_CR, ED_CR_RD2 | ED_CR_STP); 1053 DELAY(5000); 1054 1055 /* Make sure that we really have an 8390 based board */ 1056 if (!ed98_probe_generic8390(sc)) 1057 return (ENXIO); 1058 1059 /* 1060 * Set window ethernet address area 1061 * board memory base 0x480000 data 256byte 1062 */ 1063 ed_winsel_CNET98(sc, 0x4800); 1064 1065 /* 1066 * Get station address from on-board ROM 1067 */ 1068 bus_space_read_region_1(sc->mem_bst, sc->mem_bsh, sc->mem_start, 1069 sc->enaddr, ETHER_ADDR_LEN); 1070 1071 sc->vendor = ED_VENDOR_MISC; 1072 sc->type_str = "CNET98"; 1073 sc->isa16bit = 0; 1074 sc->cr_proto = ED_CR_RD2; 1075 1076 /* 1077 * Set window buffer memory area 1078 * board memory base 0x400000 data 16kbyte 1079 */ 1080 ed_winsel_CNET98(sc, 0x4000); 1081 1082 error = ed_clear_memory(dev); 1083 if (error) 1084 return (error); 1085 1086 sc->mem_shared = 1; 1087 sc->mem_end = sc->mem_start + sc->mem_size; 1088 1089 sc->txb_cnt = 1; /* XXX */ 1090 sc->tx_page_start = 0; 1091 1092 sc->rec_page_start = sc->tx_page_start + ED_TXBUF_SIZE; 1093 sc->rec_page_stop = sc->tx_page_start + sc->mem_size / ED_PAGE_SIZE; 1094 1095 sc->mem_ring = sc->mem_start + ED_PAGE_SIZE * ED_TXBUF_SIZE; 1096 1097 /* 1098 * Set interrupt level 1099 */ 1100 error = bus_get_resource(dev, SYS_RES_IRQ, 0, &conf_irq, &junk); 1101 if (error) 1102 return (error); 1103 1104 switch (conf_irq) { 1105 case 3: 1106 tmp = ED_CNET98_INT_IRQ3; 1107 break; 1108 case 5: 1109 tmp = ED_CNET98_INT_IRQ5; 1110 break; 1111 case 6: 1112 tmp = ED_CNET98_INT_IRQ6; 1113 break; 1114 case 9: 1115 tmp = ED_CNET98_INT_IRQ9; 1116 break; 1117 case 12: 1118 tmp = ED_CNET98_INT_IRQ12; 1119 break; 1120 case 13: 1121 tmp = ED_CNET98_INT_IRQ13; 1122 break; 1123 default: 1124 device_printf(dev, "Invalid irq configuration (%ld) must be " 1125 "%s for %s\n", conf_irq, "3,5,6,9,12,13", "CNET98"); 1126 return (ENXIO); 1127 } 1128 ed_asic_outb(sc, ED_CNET98_INT_LEV, tmp); 1129 DELAY(1000); 1130 /* 1131 * Set interrupt mask. 1132 * bit7:1 all interrupt mask 1133 * bit1:1 timer interrupt mask 1134 * bit0:0 NS controler interrupt enable 1135 */ 1136 ed_asic_outb(sc, ED_CNET98_INT_MASK, 0x7e); 1137 DELAY(1000); 1138 1139 return (0); 1140} 1141 1142/* 1143 * Probe and vendor-specific initialization routine for C-NET(98)E/L boards 1144 */ 1145static int 1146ed_probe_CNET98EL(device_t dev, int port_rid, int flags) 1147{ 1148 struct ed_softc *sc = device_get_softc(dev); 1149 int error; 1150 int i; 1151 u_char romdata[ETHER_ADDR_LEN * 2], tmp; 1152 u_long conf_irq, junk; 1153 1154 error = ed98_alloc_port(dev, port_rid); 1155 if (error) 1156 return (error); 1157 1158 sc->asic_offset = ED_NOVELL_ASIC_OFFSET; 1159 sc->nic_offset = ED_NOVELL_NIC_OFFSET; 1160 1161 /* Check I/O address. 0x[0-f]3d0 are allowed. */ 1162 if ((rman_get_start(sc->port_res) & 0x0fff) != 0x03d0) { 1163#ifdef DIAGNOSTIC 1164 device_printf(dev, "Invalid i/o port configuration (0x%lx) " 1165 "must be %s for %s\n", rman_get_start(sc->port_res), 1166 "0x?3d0", "CNET98E/L"); 1167#endif 1168 return (ENXIO); 1169 } 1170 1171 /* Reset the board */ 1172 ed_reset_CNET98(sc, flags); 1173 1174 /* 1175 * This is needed because some NE clones apparently don't reset the 1176 * NIC properly (or the NIC chip doesn't reset fully on power-up) XXX 1177 * - this makes the probe invasive! ...Done against my better 1178 * judgement. -DLG 1179 */ 1180 ed_nic_outb(sc, ED_P0_CR, ED_CR_RD2 | ED_CR_STP); 1181 DELAY(5000); 1182 1183 /* Make sure that we really have an 8390 based board */ 1184 if (!ed98_probe_generic8390(sc)) 1185 return (ENXIO); 1186 1187 /* Test memory via PIO */ 1188 sc->cr_proto = ED_CR_RD2; 1189 if (!ed_pio_testmem(sc, ED_CNET98EL_PAGE_OFFSET, 1, flags)) 1190 return (ENXIO); 1191 1192 /* This looks like a C-NET(98)E/L board. */ 1193 sc->type_str = "CNET98E/L"; 1194 1195 /* 1196 * Set IRQ. C-NET(98)E/L only allows a choice of irq 3,5,6. 1197 */ 1198 error = bus_get_resource(dev, SYS_RES_IRQ, 0, &conf_irq, &junk); 1199 if (error) 1200 return (error); 1201 1202 switch (conf_irq) { 1203 case 3: 1204 tmp = ED_CNET98EL_ICR_IRQ3; 1205 break; 1206 case 5: 1207 tmp = ED_CNET98EL_ICR_IRQ5; 1208 break; 1209 case 6: 1210 tmp = ED_CNET98EL_ICR_IRQ6; 1211 break; 1212#if 0 1213 case 12: 1214 tmp = ED_CNET98EL_ICR_IRQ12; 1215 break; 1216#endif 1217 default: 1218 device_printf(dev, "Invalid irq configuration (%ld) must be " 1219 "%s for %s\n", conf_irq, "3,5,6", "CNET98E/L"); 1220 return (ENXIO); 1221 } 1222 ed_asic_outb(sc, ED_CNET98EL_ICR, tmp); 1223 ed_asic_outb(sc, ED_CNET98EL_IMR, 0x7e); 1224 1225 /* Get station address from on-board ROM */ 1226 ed_pio_readmem(sc, 16384, romdata, sizeof(romdata)); 1227 for (i = 0; i < ETHER_ADDR_LEN; i++) 1228 sc->enaddr[i] = romdata[i * 2]; 1229 1230 /* clear any pending interrupts that might have occurred above */ 1231 ed_nic_outb(sc, ED_P0_ISR, 0xff); 1232 1233 return (0); 1234} 1235 1236/* 1237 * Probe and vendor-specific initialization routine for PC-9801-77 boards 1238 */ 1239static int 1240ed_probe_NEC77(device_t dev, int port_rid, int flags) 1241{ 1242 struct ed_softc *sc = device_get_softc(dev); 1243 int error; 1244 u_char tmp; 1245 u_long conf_irq, junk; 1246 1247 error = ed98_probe_Novell(dev, port_rid, flags); 1248 if (error) 1249 return (error); 1250 1251 /* LA/T-98 does not need IRQ setting. */ 1252 if (ED_TYPE98SUB(flags) == 0) 1253 return (0); 1254 1255 /* 1256 * Set IRQ. PC-9801-77 only allows a choice of irq 3,5,6,12,13. 1257 */ 1258 error = bus_get_resource(dev, SYS_RES_IRQ, 0, &conf_irq, &junk); 1259 if (error) 1260 return (error); 1261 1262 switch (conf_irq) { 1263 case 3: 1264 tmp = ED_NEC77_IRQ3; 1265 break; 1266 case 5: 1267 tmp = ED_NEC77_IRQ5; 1268 break; 1269 case 6: 1270 tmp = ED_NEC77_IRQ6; 1271 break; 1272 case 12: 1273 tmp = ED_NEC77_IRQ12; 1274 break; 1275 case 13: 1276 tmp = ED_NEC77_IRQ13; 1277 break; 1278 default: 1279 device_printf(dev, "Invalid irq configuration (%ld) must be " 1280 "%s for %s\n", conf_irq, "3,5,6,12,13", "PC-9801-77"); 1281 return (ENXIO); 1282 } 1283 ed_asic_outb(sc, ED_NEC77_IRQ, tmp); 1284 1285 return (0); 1286} 1287 1288/* 1289 * Probe and vendor-specific initialization routine for EC/EP-98X boards 1290 */ 1291static int 1292ed_probe_NW98X(device_t dev, int port_rid, int flags) 1293{ 1294 struct ed_softc *sc = device_get_softc(dev); 1295 int error; 1296 u_char tmp; 1297 u_long conf_irq, junk; 1298 1299 error = ed98_probe_Novell(dev, port_rid, flags); 1300 if (error) 1301 return (error); 1302 1303 /* Networld 98X3 does not need IRQ setting. */ 1304 if (ED_TYPE98SUB(flags) == 0) 1305 return (0); 1306 1307 /* 1308 * Set IRQ. EC/EP-98X only allows a choice of irq 3,5,6,12,13. 1309 */ 1310 error = bus_get_resource(dev, SYS_RES_IRQ, 0, &conf_irq, &junk); 1311 if (error) 1312 return (error); 1313 1314 switch (conf_irq) { 1315 case 3: 1316 tmp = ED_NW98X_IRQ3; 1317 break; 1318 case 5: 1319 tmp = ED_NW98X_IRQ5; 1320 break; 1321 case 6: 1322 tmp = ED_NW98X_IRQ6; 1323 break; 1324 case 12: 1325 tmp = ED_NW98X_IRQ12; 1326 break; 1327 case 13: 1328 tmp = ED_NW98X_IRQ13; 1329 break; 1330 default: 1331 device_printf(dev, "Invalid irq configuration (%ld) must be " 1332 "%s for %s\n", conf_irq, "3,5,6,12,13", "EC/EP-98X"); 1333 return (ENXIO); 1334 } 1335 ed_asic_outb(sc, ED_NW98X_IRQ, tmp); 1336 1337 return (0); 1338} 1339 1340/* 1341 * Read SB-9801 station address from Serial Two-Wire EEPROM 1342 */ 1343static void 1344ed_get_SB98(struct ed_softc *sc) 1345{ 1346 int i, j; 1347 u_char mask, val; 1348 1349 /* enable EEPROM acceess */ 1350 ed_asic_outb(sc, ED_SB98_EEPENA, ED_SB98_EEPENA_ENABLE); 1351 1352 /* output start command */ 1353 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SDA | ED_SB98_EEP_SCL); 1354 DELAY(ED_SB98_EEP_DELAY); 1355 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SCL); 1356 DELAY(ED_SB98_EEP_DELAY); 1357 1358 /* output address (7bit) */ 1359 for (mask = 0x40; mask != 0; mask >>= 1) { 1360 val = 0; 1361 if (ED_SB98_ADDRESS & mask) 1362 val = ED_SB98_EEP_SDA; 1363 ed_asic_outb(sc, ED_SB98_EEP, val); 1364 DELAY(ED_SB98_EEP_DELAY); 1365 ed_asic_outb(sc, ED_SB98_EEP, val | ED_SB98_EEP_SCL); 1366 DELAY(ED_SB98_EEP_DELAY); 1367 } 1368 1369 /* output READ command */ 1370 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_READ); 1371 DELAY(ED_SB98_EEP_DELAY); 1372 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_READ | ED_SB98_EEP_SCL); 1373 DELAY(ED_SB98_EEP_DELAY); 1374 1375 /* read station address */ 1376 for (i = 0; i < ETHER_ADDR_LEN; i++) { 1377 /* output ACK */ 1378 ed_asic_outb(sc, ED_SB98_EEP, 0); 1379 DELAY(ED_SB98_EEP_DELAY); 1380 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SCL); 1381 DELAY(ED_SB98_EEP_DELAY); 1382 1383 val = 0; 1384 for (j = 0; j < 8; j++) { 1385 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SDA); 1386 DELAY(ED_SB98_EEP_DELAY); 1387 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SDA | ED_SB98_EEP_SCL); 1388 DELAY(ED_SB98_EEP_DELAY); 1389 val <<= 1; 1390 val |= (ed_asic_inb(sc, ED_SB98_EEP) & ED_SB98_EEP_SDA); 1391 DELAY(ED_SB98_EEP_DELAY); 1392 } 1393 sc->enaddr[i] = val; 1394 } 1395 1396 /* output Last ACK */ 1397 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SDA); 1398 DELAY(ED_SB98_EEP_DELAY); 1399 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SDA | ED_SB98_EEP_SCL); 1400 DELAY(ED_SB98_EEP_DELAY); 1401 1402 /* output stop command */ 1403 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SCL); 1404 DELAY(ED_SB98_EEP_DELAY); 1405 ed_asic_outb(sc, ED_SB98_EEP, ED_SB98_EEP_SDA | ED_SB98_EEP_SCL); 1406 DELAY(ED_SB98_EEP_DELAY); 1407 1408 /* disable EEPROM access */ 1409 ed_asic_outb(sc, ED_SB98_EEPENA, ED_SB98_EEPENA_DISABLE); 1410} 1411 1412/* 1413 * Probe and vendor-specific initialization routine for SB-9801 boards 1414 */ 1415static int 1416ed_probe_SB98(device_t dev, int port_rid, int flags) 1417{ 1418 struct ed_softc *sc = device_get_softc(dev); 1419 int error; 1420 u_char tmp; 1421 u_long conf_irq, junk; 1422 1423 error = ed98_alloc_port(dev, port_rid); 1424 if (error) 1425 return (error); 1426 1427 sc->asic_offset = ED_NOVELL_ASIC_OFFSET; 1428 sc->nic_offset = ED_NOVELL_NIC_OFFSET; 1429 1430 /* Check I/O address. 00d[02468ace] are allowed. */ 1431 if ((rman_get_start(sc->port_res) & ~0x000e) != 0x00d0) { 1432#ifdef DIAGNOSTIC 1433 device_printf(dev, "Invalid i/o port configuration (0x%lx) " 1434 "must be %s for %s\n", rman_get_start(sc->port_res), 1435 "0xd?", "SB9801"); 1436#endif 1437 return (ENXIO); 1438 } 1439 1440 /* Write I/O port address and read 4 times */ 1441 outb(ED_SB98_IO_INHIBIT, rman_get_start(sc->port_res) & 0xff); 1442 (void) inb(ED_SB98_IO_INHIBIT); DELAY(300); 1443 (void) inb(ED_SB98_IO_INHIBIT); DELAY(300); 1444 (void) inb(ED_SB98_IO_INHIBIT); DELAY(300); 1445 (void) inb(ED_SB98_IO_INHIBIT); DELAY(300); 1446 1447 /* 1448 * Check IRQ. Soliton SB-9801 only allows a choice of 1449 * irq 3,5,6,12 1450 */ 1451 error = bus_get_resource(dev, SYS_RES_IRQ, 0, &conf_irq, &junk); 1452 if (error) 1453 return (error); 1454 1455 switch (conf_irq) { 1456 case 3: 1457 tmp = ED_SB98_CFG_IRQ3; 1458 break; 1459 case 5: 1460 tmp = ED_SB98_CFG_IRQ5; 1461 break; 1462 case 6: 1463 tmp = ED_SB98_CFG_IRQ6; 1464 break; 1465 case 12: 1466 tmp = ED_SB98_CFG_IRQ12; 1467 break; 1468 default: 1469 device_printf(dev, "Invalid irq configuration (%ld) must be " 1470 "%s for %s\n", conf_irq, "3,5,6,12", "SB9801"); 1471 return (ENXIO); 1472 } 1473 1474 if (flags & ED_FLAGS_DISABLE_TRANCEIVER) 1475 tmp |= ED_SB98_CFG_ALTPORT; 1476 ed_asic_outb(sc, ED_SB98_CFG, ED_SB98_CFG_ENABLE | tmp); 1477 ed_asic_outb(sc, ED_SB98_POLARITY, 0x01); 1478 1479 /* Reset the board. */ 1480 ed_asic_outb(sc, ED_NOVELL_RESET, 0x7a); 1481 DELAY(300); 1482 ed_asic_outb(sc, ED_NOVELL_RESET, 0x79); 1483 DELAY(300); 1484 1485 /* 1486 * This is needed because some NE clones apparently don't reset the 1487 * NIC properly (or the NIC chip doesn't reset fully on power-up) XXX 1488 * - this makes the probe invasive! ...Done against my better 1489 * judgement. -DLG 1490 */ 1491 ed_nic_outb(sc, ED_P0_CR, ED_CR_RD2 | ED_CR_STP); 1492 DELAY(5000); 1493 1494 /* Make sure that we really have an 8390 based board */ 1495 if (!ed98_probe_generic8390(sc)) 1496 return (ENXIO); 1497 1498 /* Test memory via PIO */ 1499 sc->cr_proto = ED_CR_RD2; 1500 if (!ed_pio_testmem(sc, 16384, 1, flags)) { 1501 return (ENXIO); 1502 } 1503 1504 /* This looks like an SB9801 board. */ 1505 sc->type_str = "SB9801"; 1506 1507 /* Get station address */ 1508 ed_get_SB98(sc); 1509 1510 /* clear any pending interrupts that might have occurred above */ 1511 ed_nic_outb(sc, ED_P0_ISR, 0xff); 1512 1513 return (0); 1514} 1515 1516/* 1517 * Test the ability to read and write to the NIC memory. 1518 */ 1519static int 1520ed_pio_testmem(struct ed_softc *sc, int page_offset, int isa16bit, int flags) 1521{ 1522 u_long memsize; 1523 static char test_pattern[32] = "THIS is A memory TEST pattern"; 1524 char test_buffer[32]; 1525#ifdef DIAGNOSTIC 1526 int page_end; 1527#endif 1528 1529 sc->vendor = ED_VENDOR_NOVELL; 1530 sc->mem_shared = 0; 1531 sc->isa16bit = isa16bit; 1532 1533 /* 8k of memory plus an additional 8k if 16bit */ 1534 memsize = (isa16bit ? 16384 : 8192); 1535 1536 /* 1537 * This prevents packets from being stored in the NIC memory when the 1538 * readmem routine turns on the start bit in the CR. 1539 */ 1540 ed_nic_outb(sc, ED_P0_RCR, ED_RCR_MON); 1541 1542 /* Initialize DCR for byte/word operations */ 1543 if (isa16bit) 1544 ed_nic_outb(sc, ED_P0_DCR, ED_DCR_WTS | ED_DCR_FT1 | ED_DCR_LS); 1545 else 1546 ed_nic_outb(sc, ED_P0_DCR, ED_DCR_FT1 | ED_DCR_LS); 1547 ed_nic_outb(sc, ED_P0_PSTART, page_offset / ED_PAGE_SIZE); 1548 ed_nic_outb(sc, ED_P0_PSTOP, (page_offset + memsize) / ED_PAGE_SIZE); 1549#ifdef ED_DEBUG 1550 printf("ed?: ed_pio_testmem: page start=%x, end=%lx", 1551 page_offset, page_offset + memsize); 1552#endif 1553 1554 /* 1555 * Write a test pattern. If this fails, then we don't know 1556 * what this board is. 1557 */ 1558 ed_pio_writemem(sc, test_pattern, page_offset, sizeof(test_pattern)); 1559 ed_pio_readmem(sc, page_offset, test_buffer, sizeof(test_pattern)); 1560 1561 if (bcmp(test_pattern, test_buffer, sizeof(test_pattern))) { 1562#ifdef ED_DEBUG 1563 printf("ed?: ed_pio_testmem: bcmp(page %x) NG", page_offset); 1564#endif 1565 return (0); 1566 } 1567 1568#ifdef DIAGNOSTIC 1569 /* Check the bottom. */ 1570 page_end = page_offset + memsize - ED_PAGE_SIZE; 1571 ed_pio_writemem(sc, test_pattern, page_end, sizeof(test_pattern)); 1572 ed_pio_readmem(sc, page_end, test_buffer, sizeof(test_pattern)); 1573 1574 if (bcmp(test_pattern, test_buffer, sizeof(test_pattern))) { 1575#ifdef ED_DEBUG 1576 printf("ed?: ed_pio_testmem: bcmp(page %x) NG", page_end); 1577#endif 1578 return (0); 1579 } 1580#endif 1581 sc->mem_size = memsize; 1582 sc->mem_start = page_offset; 1583 sc->mem_end = sc->mem_start + memsize; 1584 sc->tx_page_start = page_offset / ED_PAGE_SIZE; 1585 1586 /* 1587 * Use one xmit buffer if < 16k, two buffers otherwise (if not told 1588 * otherwise). 1589 */ 1590 if ((memsize < 16384) || (flags & ED_FLAGS_NO_MULTI_BUFFERING)) 1591 sc->txb_cnt = 1; 1592 else 1593 sc->txb_cnt = 2; 1594 1595 sc->rec_page_start = sc->tx_page_start + sc->txb_cnt * ED_TXBUF_SIZE; 1596 sc->rec_page_stop = sc->tx_page_start + memsize / ED_PAGE_SIZE; 1597 1598 sc->mem_ring = sc->mem_start + sc->txb_cnt * ED_PAGE_SIZE * ED_TXBUF_SIZE; 1599 1600 return (1); 1601} 1602 1603static device_method_t ed_cbus_methods[] = { 1604 /* Device interface */ 1605 DEVMETHOD(device_probe, ed_cbus_probe), 1606 DEVMETHOD(device_attach, ed_cbus_attach), 1607 DEVMETHOD(device_attach, ed_detach), 1608 1609 { 0, 0 } 1610}; 1611 1612static driver_t ed_cbus_driver = { 1613 "ed", 1614 ed_cbus_methods, 1615 sizeof(struct ed_softc) 1616}; 1617 1618DRIVER_MODULE(ed, isa, ed_cbus_driver, ed_devclass, 0, 0); 1619MODULE_DEPEND(ed, isa, 1, 1, 1); 1620MODULE_DEPEND(ed, ether, 1, 1, 1); 1621