6/sys/dev/ed/if_ed_cbus.c

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