/*
 * 86Box    A hypervisor and IBM PC system emulator that specializes in
 *          running old operating systems and software designed for IBM
 *          PC systems and compatibles from 1981 through fairly recent
 *          system designs based on the PCI bus.
 *
 *          This file is part of the 86Box distribution.
 *
 *          Implementation of the following network controllers:
 *            - SMC/WD 8003E (ISA 8-bit);
 *            - SMC/WD 8013EBT (ISA 16-bit);
 *            - SMC/WD 8013EP/A (MCA).
 *
 * Authors: Fred N. van Kempen, <decwiz@yahoo.com>
 *          TheCollector1995, <mariogplayer@gmail.com>
 *          Miran Grca, <mgrca8@gmail.com>
 *          Peter Grehan, <grehan@iprg.nokia.com>
 *
 *          Copyright 2017-2019 Fred N. van Kempen.
 *          Copyright 2016-2019 Miran Grca.
 *          Portions Copyright (C) 2002  MandrakeSoft S.A.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free  Software  Foundation; either  version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is  distributed in the hope that it will be useful, but
 * WITHOUT   ANY  WARRANTY;  without  even   the  implied  warranty  of
 * MERCHANTABILITY  or FITNESS  FOR A PARTICULAR  PURPOSE. See  the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the:
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place - Suite 330
 *   Boston, MA 02111-1307
 *   USA.
 */
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdarg.h>
#include <wchar.h>
#include <time.h>
#define HAVE_STDARG_H
#include <86box/86box.h>
#include <86box/io.h>
#include <86box/mem.h>
#include <86box/rom.h>
#include <86box/machine.h>
#include <86box/mca.h>
#include <86box/pci.h>
#include <86box/pic.h>
#include <86box/random.h>
#include <86box/device.h>
#include <86box/timer.h>
#include <86box/thread.h>
#include <86box/network.h>
#include <86box/net_dp8390.h>
#include <86box/net_wd8003.h>
#include <86box/plat_fallthrough.h>
#include <86box/plat_unused.h>

#include "cpu.h"

/* Board type codes in card ID */
#define WE_TYPE_WD8003    0x01
#define WE_TYPE_WD8003S   0x02
#define WE_TYPE_WD8003E   0x03
#define WE_TYPE_WD8013EBT 0x05
#define WE_TYPE_TOSHIBA1  0x11 /* named PCETA1 */
#define WE_TYPE_TOSHIBA2  0x12 /* named PCETA2 */
#define WE_TYPE_TOSHIBA3  0x13 /* named PCETB */
#define WE_TYPE_TOSHIBA4  0x14 /* named PCETC */
#define WE_TYPE_WD8003W   0x24
#define WE_TYPE_WD8003EB  0x25
#define WE_TYPE_WD8013W   0x26
#define WE_TYPE_WD8013EP  0x27
#define WE_TYPE_WD8013WC  0x28
#define WE_TYPE_WD8013EPC 0x29
#define WE_TYPE_SMC8216T  0x2a
#define WE_TYPE_SMC8216C  0x2b
#define WE_TYPE_WD8013EBP 0x2c

#define WE_ICR_16BIT_SLOT 0x01

#define WE_MSR_ENABLE_RAM 0x40
#define WE_MSR_SOFT_RESET 0x80

#define WE_IRR_ENABLE_IRQ 0x80

#define WE_ID_ETHERNET    0x01
#define WE_ID_SOFT_CONFIG 0x20
#define WE_ID_EXTRA_RAM   0x40
#define WE_ID_BUS_MCA     0x80

typedef struct wd_t {
    dp8390_t     *dp8390;
    mem_mapping_t ram_mapping;
    uint32_t      ram_addr;
    uint32_t      ram_size;
    uint8_t       maclocal[6]; /* configured MAC (local) address */
    uint8_t       bit16;
    uint8_t       pad;
    int           board;
    const char   *name;
    uint32_t      base_address;
    int           irq;

    /* POS registers, MCA boards only */
    uint8_t pos_regs[8];

    /* Memory for WD cards*/
    uint8_t msr;        /* Memory Select Register (MSR) */
    uint8_t icr;        /* Interface Configuration Register (ICR) */
    uint8_t irr;        /* Interrupt Request Register (IRR) */
    uint8_t laar;       /* LA Address Register (read by Windows 98!) */
    uint8_t if_chip;
    uint8_t board_chip;
} wd_t;

#ifdef ENABLE_WD_LOG
int wd_do_log = ENABLE_WD_LOG;

static void
wdlog(const char *fmt, ...)
{
    va_list ap;

    if (wd_do_log) {
        va_start(ap, fmt);
        pclog_ex(fmt, ap);
        va_end(ap);
    }
}
#else
#    define wdlog(fmt, ...)
#endif

static const int we_int_table[4] = { 2, 3, 4, 7 };

static void
wd_interrupt(void *priv, int set)
{
    const wd_t *dev = (wd_t *) priv;

    if (!(dev->irr & WE_IRR_ENABLE_IRQ))
        return;

    if (set)
        picint(1 << dev->irq);
    else
        picintc(1 << dev->irq);
}

/* reset - restore state to power-up, cancelling all i/o */
static void
wd_reset(void *priv)
{
    wd_t *dev = (wd_t *) priv;

    wdlog("%s: reset\n", dev->name);

    dp8390_reset(dev->dp8390);
}

static void
wd_soft_reset(void *priv)
{
    wd_t *dev = (wd_t *) priv;

    dp8390_soft_reset(dev->dp8390);
}

static uint8_t
wd_ram_read(uint32_t addr, void *priv)
{
    const wd_t *dev = (wd_t *) priv;

    wdlog("WD80x3: RAM Read: addr=%06x, val=%02x\n", addr & (dev->ram_size - 1), dev->dp8390->mem[addr & (dev->ram_size - 1)]);
    return dev->dp8390->mem[addr & (dev->ram_size - 1)];
}

static void
wd_ram_write(uint32_t addr, uint8_t val, void *priv)
{
    wd_t *dev = (wd_t *) priv;

    dev->dp8390->mem[addr & (dev->ram_size - 1)] = val;
    wdlog("WD80x3: RAM Write: addr=%06x, val=%02x\n", addr & (dev->ram_size - 1), val);
}

static int
wd_get_irq_index(wd_t *dev)
{
    uint8_t irq = 255;

    for (uint8_t i = 0; i < 4; i++) {
        if (we_int_table[i] == dev->irq)
            irq = i;
    }
    if (irq != 255)
        return ((irq & 0x03) << 5);
    else

        return 0;
}

static uint32_t
wd_smc_read(wd_t *dev, uint32_t off)
{
    uint32_t retval   = 0;
    uint32_t checksum = 0;

    if (dev->board == WD8003E)
        off |= 0x08;

    switch (off) {
        case 0x00:
            if (dev->board_chip & WE_ID_BUS_MCA)
                retval = (dev->msr & 0xc0) | ((dev->ram_addr >> 13) & 0x3f);
            else
                retval = dev->msr;
            break;

        case 0x01:
            if (dev->board_chip & WE_ID_SOFT_CONFIG)
                retval = dev->icr;
            else
                retval = dev->icr & WE_ICR_16BIT_SLOT;
            break;

        case 0x04:
            if (dev->board_chip & WE_ID_SOFT_CONFIG)
                retval = (dev->irr & 0x9f) | wd_get_irq_index(dev);
            break;

        case 0x05:
            if (dev->board_chip & WE_ID_SOFT_CONFIG)
                retval = dev->laar;
            break;

        case 0x07:
            if (dev->board_chip & WE_ID_SOFT_CONFIG)
                retval = dev->if_chip;
            break;

        case 0x08:
            retval = dev->dp8390->physaddr[0];
            break;

        case 0x09:
            retval = dev->dp8390->physaddr[1];
            break;

        case 0x0a:
            retval = dev->dp8390->physaddr[2];
            break;

        case 0x0b:
            retval = dev->dp8390->physaddr[3];
            break;

        case 0x0c:
            retval = dev->dp8390->physaddr[4];
            break;

        case 0x0d:
            retval = dev->dp8390->physaddr[5];
            break;

        case 0x0e:
            retval = dev->board_chip;
            break;

        case 0x0f:
            /*This has to return the byte that adds up to 0xFF*/
            checksum = (dev->dp8390->physaddr[0] + dev->dp8390->physaddr[1] + dev->dp8390->physaddr[2] + dev->dp8390->physaddr[3] + dev->dp8390->physaddr[4] + dev->dp8390->physaddr[5] + dev->board_chip);

            retval = 0xff - (checksum & 0xff);
            break;

        default:
            break;
    }

    wdlog("%s: ASIC read addr=0x%02x, value=0x%04x\n",
          dev->name, (unsigned) off, (unsigned) retval);

    return retval;
}

static void
wd_set_ram(wd_t *dev)
{
    uint32_t a13;

    if ((dev->board_chip & 0xa0) == 0x20) {
        a13 = dev->msr & 0x3f;
        a13 <<= 13;

        dev->ram_addr = a13 | (1 << 19);
        mem_mapping_set_addr(&dev->ram_mapping, dev->ram_addr, dev->ram_size);
        wdlog("%s: RAM address set to %08X\n", dev->name, dev->ram_addr);
    }

    if (dev->msr & WE_MSR_ENABLE_RAM)
        mem_mapping_enable(&dev->ram_mapping);
    else
        mem_mapping_disable(&dev->ram_mapping);
    wdlog("%s: RAM now %sabled\n", dev->name, (dev->msr & WE_MSR_ENABLE_RAM) ? "en" : "dis");
}

static void
wd_smc_write(wd_t *dev, uint32_t off, uint32_t val)
{
    uint8_t old;

    wdlog("%s: ASIC write addr=0x%02x, value=0x%04x\n",
          dev->name, (unsigned) off, (unsigned) val);

    if (off && (dev->board == WD8003E))
        return;

    switch (off) {
        /* Bits 0-5: Bits 13-18 of memory address (writable?):
                     Windows 98 requires this to be preloaded with the initial
                     addresss to work correctly;
           Bit 6: Enable memory if set;
           Bit 7: Software reset if set. */
        case 0x00: /* WD Control register */
            old = dev->msr;

            if (!(old & WE_MSR_SOFT_RESET) && (val & WE_MSR_SOFT_RESET)) {
                wd_soft_reset(dev);
                wdlog("WD80x3: Soft reset\n");
            }

            if ((dev->board_chip & 0xa0) == 0x20)
                dev->msr = val;
            else
                dev->msr = (dev->msr & 0x3f) | (val & 0xc0);

            if ((old &= 0x7f) != (val & 0x7f)) {
                wd_set_ram(dev);
                wdlog("WD80x3: Memory now %sabled (addr = %08X)\n", (val & WE_MSR_ENABLE_RAM) ? "en" : "dis", dev->ram_addr);
            }
            break;

        /* Bit 1: 0 = 8-bit slot, 1 = 16-bit slot;
           Bit 3: 0 = 8k RAM, 1 = 32k RAM (only on revision < 2). */
        case 0x01:
            if (dev->bit16 & 2)
                dev->icr = (dev->icr & WE_ICR_16BIT_SLOT) | (val & WE_ICR_16BIT_SLOT);
            else
                dev->icr = val;
            break;

        /* Bit 5: Bit 0 of encoded IRQ;
           Bit 6: Bit 1 of encoded IRQ;
           Bit 7: Enable interrupts. */
        case 0x04:
            if (dev->board_chip & WE_ID_SOFT_CONFIG)
                dev->irr = (dev->irr & 0xe0) | (val & 0x1f);
            break;

        /* Bits 0-4: Bits 19-23 of memory address (writable?):
                     Windows 98 requires this to be preloaded with the initial
                     addresss to work correctly;
           Bit 5: Enable software interrupt;
           Bit 6: Enable 16-bit RAM for LAN if set;
           Bit 7: Enable 16-bit RAM for host if set. */
        case 0x05:
            if (dev->board_chip & WE_ID_SOFT_CONFIG)
                dev->laar = val;
            break;

        /* Bits 0-4: Chip ID;
           Bit 5: Software configuration is supported if present;
           Bit 6: 0 = 16k RAM, 1 = 32k RAM. */
        case 0x07:
            if (dev->board_chip & WE_ID_SOFT_CONFIG)
                dev->if_chip = val;
            break;

        default:
            /* This is invalid, but happens under win95 device detection:
               maybe some clone cards implement writing for some other
               registers? */
            wdlog("%s: ASIC write invalid address %04x, ignoring\n",
                  dev->name, (unsigned) off);
            break;
    }
}

static uint8_t
wd_read(uint16_t addr, void *priv, int len)
{
    wd_t *dev = (wd_t *) priv;

    uint8_t retval = 0;
    int     off    = addr - dev->base_address;

    wdlog("%s: read addr %x\n", dev->name, addr);

    if (off == 0x10)
        retval = dp8390_read_cr(dev->dp8390);
    else if ((off >= 0x00) && (off <= 0x0f))
        retval = wd_smc_read(dev, off);
    else {
        switch (dev->dp8390->CR.pgsel) {
            case 0x00:
                retval = dp8390_page0_read(dev->dp8390, off - 0x10, len);
                break;
            case 0x01:
                retval = dp8390_page1_read(dev->dp8390, off - 0x10, len);
                break;
            case 0x02:
                retval = dp8390_page2_read(dev->dp8390, off - 0x10, len);
                break;
            default:
                wdlog("%s: unknown value of pgsel in read - %d\n",
                      dev->name, dev->dp8390->CR.pgsel);
                break;
        }
    }

    return retval;
}

static uint8_t
wd_readb(uint16_t addr, void *priv)
{
    wd_t *dev = (wd_t *) priv;

    return (wd_read(addr, dev, 1));
}

static uint16_t
wd_readw(uint16_t addr, void *priv)
{
    wd_t *dev = (wd_t *) priv;

    return (wd_read(addr, dev, 2));
}

static void
wd_write(uint16_t addr, uint8_t val, void *priv, unsigned int len)
{
    wd_t *dev = (wd_t *) priv;
    int   off = addr - dev->base_address;

    wdlog("%s: write addr %x, value %x\n", dev->name, addr, val);

    if (off == 0x10)
        dp8390_write_cr(dev->dp8390, val);
    else if ((off >= 0x00) && (off <= 0x0f))
        wd_smc_write(dev, off, val);
    else {
        switch (dev->dp8390->CR.pgsel) {
            case 0x00:
                dp8390_page0_write(dev->dp8390, off - 0x10, val, len);
                break;
            case 0x01:
                dp8390_page1_write(dev->dp8390, off - 0x10, val, len);
                break;
            default:
                wdlog("%s: unknown value of pgsel in write - %d\n",
                      dev->name, dev->dp8390->CR.pgsel);
                break;
        }
    }
}

static void
wd_writeb(uint16_t addr, uint8_t val, void *priv)
{
    wd_write(addr, val, priv, 1);
}

static void
wd_writew(uint16_t addr, uint16_t val, void *priv)
{
    wd_write(addr, val & 0xff, priv, 2);
}

static void
wd_io_set(wd_t *dev, uint16_t addr)
{
    if (dev->bit16 & 1) {
        io_sethandler(addr, 0x20,
                      wd_readb, wd_readw, NULL,
                      wd_writeb, wd_writew, NULL, dev);
    } else {
        io_sethandler(addr, 0x20,
                      wd_readb, NULL, NULL,
                      wd_writeb, NULL, NULL, dev);
    }
}

static void
wd_io_remove(wd_t *dev, uint16_t addr)
{
    if (dev->bit16 & 1) {
        io_removehandler(addr, 0x20,
                         wd_readb, wd_readw, NULL,
                         wd_writeb, wd_writew, NULL, dev);
    } else {
        io_removehandler(addr, 0x20,
                         wd_readb, NULL, NULL,
                         wd_writeb, NULL, NULL, dev);
    }
}

static uint8_t
wd_mca_read(int port, void *priv)
{
    const wd_t *dev = (wd_t *) priv;

    return (dev->pos_regs[port & 7]);
}

#define MCA_6FC0_IRQS \
    {                 \
        3, 4, 10, 15  \
    }

static void
wd_mca_write(int port, uint8_t val, void *priv)
{
    wd_t  *dev    = (wd_t *) priv;
    int8_t irq[4] = MCA_6FC0_IRQS;

    /* MCA does not write registers below 0x0100. */
    if (port < 0x0102)
        return;

    /* Save the MCA register value. */
    dev->pos_regs[port & 7] = val;

    /*
     * The PS/2 Model 80 BIOS always enables a card if it finds one,
     * even if no resources were assigned yet (because we only added
     * the card, but have not run AutoConfig yet...)
     *
     * So, remove current address, if any.
     */
    if (dev->base_address)
        wd_io_remove(dev, dev->base_address);

    dev->base_address = (dev->pos_regs[2] & 0xfe) << 4;
    dev->ram_addr     = (dev->pos_regs[3] & 0xfc) << 12;
    dev->irq          = irq[dev->pos_regs[5] & 0x03];

    /* Initialize the device if fully configured. */
    /* Register (new) I/O handler. */
    if (dev->pos_regs[2] & 0x01)
        wd_io_set(dev, dev->base_address);

    mem_mapping_set_addr(&dev->ram_mapping, dev->ram_addr, dev->ram_size);

    mem_mapping_disable(&dev->ram_mapping);
    if ((dev->msr & WE_MSR_ENABLE_RAM) && (dev->pos_regs[2] & 0x01))
        mem_mapping_enable(&dev->ram_mapping);

    wdlog("%s: attached IO=0x%X IRQ=%d, RAM addr=0x%06x\n", dev->name,
          dev->base_address, dev->irq, dev->ram_addr);
}

static void
wd_8013epa_mca_write(int port, uint8_t val, void *priv)
{
    wd_t *dev = (wd_t *) priv;

    /* MCA does not write registers below 0x0100. */
    if (port < 0x0102)
        return;

    /* Save the MCA register value. */
    dev->pos_regs[port & 7] = val;

    /*
     * The PS/2 Model 80 BIOS always enables a card if it finds one,
     * even if no resources were assigned yet (because we only added
     * the card, but have not run AutoConfig yet...)
     *
     * So, remove current address, if any.
     */
    if (dev->base_address)
        wd_io_remove(dev, dev->base_address);

    dev->base_address = 0x800 + ((dev->pos_regs[2] & 0xf0) << 8);

    switch (dev->pos_regs[5] & 0x0c) {
        case 0:
            dev->irq = 3;
            break;
        case 4:
            dev->irq = 4;
            break;
        case 8:
            dev->irq = 10;
            break;
        case 0x0c:
            dev->irq = 14;
            break;

        default:
            break;
    }

    if (dev->pos_regs[3] & 0x10)
        dev->ram_size = 0x4000;
    else
        dev->ram_size = 0x2000;

    dev->ram_addr = ((dev->pos_regs[3] & 0x0f) << 13) + 0xc0000;
    if (dev->pos_regs[3] & 0x80)
        dev->ram_addr += 0xf00000;

    /* Initialize the device if fully configured. */
    /* Register (new) I/O handler. */
    if (dev->pos_regs[2] & 0x01)
        wd_io_set(dev, dev->base_address);

    mem_mapping_set_addr(&dev->ram_mapping, dev->ram_addr, dev->ram_size);

    mem_mapping_disable(&dev->ram_mapping);
    if ((dev->msr & WE_MSR_ENABLE_RAM) && (dev->pos_regs[2] & 0x01))
        mem_mapping_enable(&dev->ram_mapping);

    wdlog("%s: attached IO=0x%X IRQ=%d, RAM addr=0x%06x\n", dev->name,
          dev->base_address, dev->irq, dev->ram_addr);
}

static uint8_t
wd_mca_feedb(UNUSED(void *priv))
{
    return 1;
}

static void *
wd_init(const device_t *info)
{
    uint32_t mac;
    wd_t    *dev;

    dev = calloc(1, sizeof(wd_t));
    dev->name  = info->name;
    dev->board = info->local;

    dev->maclocal[0] = 0x00; /* 00:00:C0 (WD/SMC OID) */
    dev->maclocal[1] = 0x00;
    dev->maclocal[2] = 0xC0;

    /* See if we have a local MAC address configured. */
    mac = device_get_config_mac("mac", -1);

    /* Set up our BIA. */
    if (mac & 0xff000000) {
        /* Generate new local MAC. */
        dev->maclocal[3] = random_generate();
        dev->maclocal[4] = random_generate();
        dev->maclocal[5] = random_generate();
        mac              = (((int) dev->maclocal[3]) << 16);
        mac |= (((int) dev->maclocal[4]) << 8);
        mac |= ((int) dev->maclocal[5]);
        device_set_config_mac("mac", mac);
    } else {
        dev->maclocal[3] = (mac >> 16) & 0xff;
        dev->maclocal[4] = (mac >> 8) & 0xff;
        dev->maclocal[5] = (mac & 0xff);
    }

    if ((dev->board == WD8003ETA) || (dev->board == WD8003EA) || dev->board == WD8013EPA) {
        if (dev->board == WD8013EPA)
            mca_add(wd_mca_read, wd_8013epa_mca_write, wd_mca_feedb, NULL, dev);
        else
            mca_add(wd_mca_read, wd_mca_write, wd_mca_feedb, NULL, dev);
    } else {
        dev->base_address = device_get_config_hex16("base");
        dev->irq          = device_get_config_int("irq");
        dev->ram_addr     = device_get_config_hex20("ram_addr");
    }

    dev->dp8390            = device_add_inst(&dp8390_device, dp3890_inst++);
    dev->dp8390->priv      = dev;
    dev->dp8390->interrupt = wd_interrupt;
    dp8390_set_defaults(dev->dp8390, DP8390_FLAG_CHECK_CR | DP8390_FLAG_CLEAR_IRQ);

    switch (dev->board) {
        /* Ethernet, ISA, no interface chip, RAM 8k */
        case WD8003E:
            dev->board_chip = WE_TYPE_WD8003E;
            dev->ram_size   = 0x2000;
            break;

        /* Ethernet, ISA, 5x3 interface chip, RAM 8k or 32k */
        case WD8003EB:
            dev->board_chip = WE_TYPE_WD8003EB;
            dev->if_chip    = 1;
            dev->ram_size   = device_get_config_int("ram_size");
            if (dev->ram_size == 0x8000)
                dev->board_chip |= WE_ID_EXTRA_RAM;

            /* Bit A19 is implicit 1. */
            dev->msr |= (dev->ram_addr >> 13) & 0x3f;
            break;

        /* Ethernet, ISA, no interface chip, RAM 8k or 32k (8-bit slot) / 16k or 64k (16-bit slot) */
        case WD8013EBT:
            dev->board_chip = WE_TYPE_WD8013EBT;
            dev->ram_size   = device_get_config_int("ram_size");
            if (dev->ram_size == 0x10000)
                dev->board_chip |= WE_ID_EXTRA_RAM;

            dev->bit16 = 2;
            if (is286)
                dev->bit16 |= 1;
            else {
                dev->bit16 |= 0;
                if (dev->irq == 9)
                    dev->irq = 2;
                dev->ram_size >>= 1; /* Half the RAM when in 8-bit slot. */
            }
            break;

        /* Ethernet, MCA, 5x3 interface chip, RAM 16k */
        case WD8003EA:
            dev->board_chip = WE_ID_SOFT_CONFIG;
            fallthrough;

        /* Ethernet, MCA, no interface chip, RAM 16k */
        case WD8003ETA:
            dev->board_chip |= WE_TYPE_WD8013EBT | WE_ID_BUS_MCA;
            dev->ram_size    = 0x4000;
            dev->pos_regs[0] = 0xC0;
            dev->pos_regs[1] = 0x6F;
            dev->bit16       = 3;
            break;

        case WD8013EPA:
            dev->board_chip  = WE_TYPE_WD8013EP | WE_ID_BUS_MCA;
            dev->ram_size    = device_get_config_int("ram_size");
            dev->pos_regs[0] = 0xC8;
            dev->pos_regs[1] = 0x61;
            dev->bit16       = 3;
            break;

        default:
            break;
    }

    dev->irr |= WE_IRR_ENABLE_IRQ;
    dev->icr |= (dev->bit16 & 0x01);

    dp8390_mem_alloc(dev->dp8390, 0x0000, dev->ram_size);

    if (dev->base_address)
        wd_io_set(dev, dev->base_address);

    memcpy(dev->dp8390->physaddr, dev->maclocal, sizeof(dev->maclocal));

    wdlog("%s: I/O=%04x, IRQ=%d, MAC=%02x:%02x:%02x:%02x:%02x:%02x\n",
          dev->name, dev->base_address, dev->irq,
          dev->dp8390->physaddr[0], dev->dp8390->physaddr[1], dev->dp8390->physaddr[2],
          dev->dp8390->physaddr[3], dev->dp8390->physaddr[4], dev->dp8390->physaddr[5]);

    /* Reset the board. */
    wd_reset(dev);

    /* Map this system into the memory map. */
    mem_mapping_add(&dev->ram_mapping, dev->ram_addr, dev->ram_size,
                    wd_ram_read, NULL, NULL,
                    wd_ram_write, NULL, NULL,
                    NULL, MEM_MAPPING_EXTERNAL, dev);

    mem_mapping_disable(&dev->ram_mapping);

    /* Attach ourselves to the network module. */
    dev->dp8390->card = network_attach(dev->dp8390, dev->dp8390->physaddr, dp8390_rx, NULL);

    if (!(dev->board_chip & WE_ID_BUS_MCA)) {
        wdlog("%s: attached IO=0x%X IRQ=%d, RAM addr=0x%06x\n", dev->name,
              dev->base_address, dev->irq, dev->ram_addr);
    }

    return dev;
}

static void
wd_close(void *priv)
{
    wd_t *dev = (wd_t *) priv;

    wdlog("%s: closed\n", dev->name);

    free(dev);
}

// clang-format off
static const device_config_t wd8003_config[] = {
    {
        .name           = "base",
        .description    = "Address",
        .type           = CONFIG_HEX16,
        .default_string = NULL,
        .default_int    = 0x300,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "0x240", .value = 0x240 },
            { .description = "0x280", .value = 0x280 },
            { .description = "0x300", .value = 0x300 },
            { .description = "0x380", .value = 0x380 },
            { .description = ""                      }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "irq",
        .description    = "IRQ",
        .type           = CONFIG_SELECTION,
        .default_string = NULL,
        .default_int    = 3,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "IRQ 2", .value = 2 },
            { .description = "IRQ 3", .value = 3 },
            { .description = "IRQ 5", .value = 5 },
            { .description = "IRQ 7", .value = 7 },
            { .description = ""                  }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "ram_addr",
        .description    = "RAM Address",
        .type           = CONFIG_HEX20,
        .default_string = NULL,
        .default_int    = 0xD0000,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "C800", .value = 0xC8000 },
            { .description = "CC00", .value = 0xCC000 },
            { .description = "D000", .value = 0xD0000 },
            { .description = "D400", .value = 0xD4000 },
            { .description = "D800", .value = 0xD8000 },
            { .description = "DC00", .value = 0xDC000 },
            { .description = ""                       }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "mac",
        .description    = "MAC Address",
        .type           = CONFIG_MAC,
        .default_string = NULL,
        .default_int    = -1,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = { { 0 } },
        .bios           = { { 0 } }
    },
    { .name = "", .description = "", .type = CONFIG_END }
};

static const device_config_t wd8003eb_config[] = {
    {
        .name           = "base",
        .description    = "Address",
        .type           = CONFIG_HEX16,
        .default_string = NULL,
        .default_int    = 0x280,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "0x200", .value = 0x200 },
            { .description = "0x220", .value = 0x220 },
            { .description = "0x240", .value = 0x240 },
            { .description = "0x260", .value = 0x260 },
            { .description = "0x280", .value = 0x280 },
            { .description = "0x2A0", .value = 0x2A0 },
            { .description = "0x2C0", .value = 0x2C0 },
            { .description = "0x300", .value = 0x300 },
            { .description = "0x340", .value = 0x340 },
            { .description = "0x380", .value = 0x380 },
            { .description = ""                      }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "irq",
        .description    = "IRQ",
        .type           = CONFIG_SELECTION,
        .default_string = NULL,
        .default_int    = 3,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "IRQ 2/9", .value = 9 },
            { .description = "IRQ 3",   .value = 3 },
            { .description = "IRQ 4",   .value = 4 },
            { .description = "IRQ 7",   .value = 7 },
            { .description = ""                    }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "ram_addr",
        .description    = "RAM Address",
        .type           = CONFIG_HEX20,
        .default_string = NULL,
        .default_int    = 0xD0000,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "C000", .value = 0xC0000 },
            { .description = "C400", .value = 0xC4000 },
            { .description = "C800", .value = 0xC8000 },
            { .description = "CC00", .value = 0xCC000 },
            { .description = "D000", .value = 0xD0000 },
            { .description = "D400", .value = 0xD4000 },
            { .description = "D800", .value = 0xD8000 },
            { .description = "DC00", .value = 0xDC000 },
            { .description = ""                       }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "ram_size",
        .description    = "RAM size",
        .type           = CONFIG_SELECTION,
        .default_string = NULL,
        .default_int    = 8192,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "8 KB",  .value =  8192 },
            { .description = "32 KB", .value = 32768 },
            { .description = ""                      }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "mac",
        .description    = "MAC Address",
        .type           = CONFIG_MAC,
        .default_string = NULL,
        .default_int    = -1,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = { { 0 } },
        .bios           = { { 0 } }
    },
    { .name = "", .description = "", .type = CONFIG_END }
};

/* WD8013EBT configuration and defaults set according to this site:
   http://www.stack.nl/~marcolz/network/wd80x3.html#WD8013EBT */
static const device_config_t wd8013_config[] = {
    {
        .name           = "base",
        .description    = "Address",
        .type           = CONFIG_HEX16,
        .default_string = NULL,
        .default_int    = 0x280,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "0x200", .value = 0x200 },
            { .description = "0x220", .value = 0x220 },
            { .description = "0x240", .value = 0x240 },
            { .description = "0x260", .value = 0x260 },
            { .description = "0x280", .value = 0x280 },
            { .description = "0x2A0", .value = 0x2A0 },
            { .description = "0x2C0", .value = 0x2C0 },
            { .description = "0x300", .value = 0x300 },
            { .description = "0x340", .value = 0x340 },
            { .description = "0x380", .value = 0x380 },
            { .description = ""                      }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "irq",
        .description    = "IRQ",
        .type           = CONFIG_SELECTION,
        .default_string = NULL,
        .default_int    = 3,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "IRQ 2/9", .value =  9 },
            { .description = "IRQ 3",   .value =  3 },
            { .description = "IRQ 4",   .value =  4 },
            { .description = "IRQ 5",   .value =  5 },
            { .description = "IRQ 7",   .value =  7 },
            { .description = "IRQ 10",  .value = 10 },
            { .description = "IRQ 11",  .value = 11 },
            { .description = "IRQ 15",  .value = 15 },
            { .description = ""                     }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "ram_addr",
        .description    = "RAM Address",
        .type           = CONFIG_HEX20,
        .default_string = NULL,
        .default_int    = 0xD0000,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "C000", .value = 0xC0000 },
            { .description = "C400", .value = 0xC4000 },
            { .description = "C800", .value = 0xC8000 },
            { .description = "CC00", .value = 0xCC000 },
            { .description = "D000", .value = 0xD0000 },
            { .description = "D400", .value = 0xD4000 },
            { .description = "D800", .value = 0xD8000 },
            { .description = "DC00", .value = 0xDC000 },
            { .description = ""                       }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "ram_size",
        .description    = "RAM size",
        .type           = CONFIG_SELECTION,
        .default_string = NULL,
        .default_int    = 16384,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "16 KB", .value = 16384 },
            { .description = "64 KB", .value = 65536 },
            { .description = ""                      }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "mac",
        .description    = "MAC Address",
        .type           = CONFIG_MAC,
        .default_string = NULL,
        .default_int    = -1,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = { { 0 } },
        .bios           = { { 0 } }
    },
    { .name = "", .description = "", .type = CONFIG_END }
};

static const device_config_t wd8013epa_config[] = {
    {
        .name           = "ram_size",
        .description    = "Initial RAM size",
        .type           = CONFIG_SELECTION,
        .default_string = NULL,
        .default_int    = 16384,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "8 KB",  .value = 8192  },
            { .description = "16 KB", .value = 16384 },
            { .description = ""                      }
        },
        .bios           = { { 0 } }
    },
    {
        .name           = "mac",
        .description    = "MAC Address",
        .type           = CONFIG_MAC,
        .default_string = NULL,
        .default_int    = -1,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = { { 0 } },
        .bios           = { { 0 } }
    },
    { .name = "", .description = "", .type = CONFIG_END }
};

static const device_config_t mca_mac_config[] = {
    {
        .name           = "mac",
        .description    = "MAC Address",
        .type           = CONFIG_MAC,
        .default_string = NULL,
        .default_int    = -1,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = { { 0 } },
        .bios           = { { 0 } }
    },
    { .name = "", .description = "", .type = CONFIG_END }
};
// clang-format on

const device_t wd8003e_device = {
    .name          = "Western Digital WD8003E",
    .internal_name = "wd8003e",
    .flags         = DEVICE_ISA,
    .local         = WD8003E,
    .init          = wd_init,
    .close         = wd_close,
    .reset         = NULL,
    .available     = NULL,
    .speed_changed = NULL,
    .force_redraw  = NULL,
    .config        = wd8003_config
};

const device_t wd8003eb_device = {
    .name          = "Western Digital WD8003EB",
    .internal_name = "wd8003eb",
    .flags         = DEVICE_ISA,
    .local         = WD8003EB,
    .init          = wd_init,
    .close         = wd_close,
    .reset         = NULL,
    .available     = NULL,
    .speed_changed = NULL,
    .force_redraw  = NULL,
    .config        = wd8003eb_config
};

const device_t wd8013ebt_device = {
    .name          = "Western Digital WD8013EBT",
    .internal_name = "wd8013ebt",
    .flags         = DEVICE_ISA,
    .local         = WD8013EBT,
    .init          = wd_init,
    .close         = wd_close,
    .reset         = NULL,
    .available     = NULL,
    .speed_changed = NULL,
    .force_redraw  = NULL,
    .config        = wd8013_config
};

const device_t wd8003eta_device = {
    .name          = "Western Digital WD8003ET/A",
    .internal_name = "wd8003eta",
    .flags         = DEVICE_MCA,
    .local         = WD8003ETA,
    .init          = wd_init,
    .close         = wd_close,
    .reset         = NULL,
    .available     = NULL,
    .speed_changed = NULL,
    .force_redraw  = NULL,
    .config        = mca_mac_config
};

const device_t wd8003ea_device = {
    .name          = "Western Digital WD8003E/A",
    .internal_name = "wd8003ea",
    .flags         = DEVICE_MCA,
    .local         = WD8003EA,
    .init          = wd_init,
    .close         = wd_close,
    .reset         = NULL,
    .available     = NULL,
    .speed_changed = NULL,
    .force_redraw  = NULL,
    .config        = mca_mac_config
};

const device_t wd8013epa_device = {
    .name          = "Western Digital WD8013EP/A",
    .internal_name = "wd8013epa",
    .flags         = DEVICE_MCA,
    .local         = WD8013EPA,
    .init          = wd_init,
    .close         = wd_close,
    .reset         = NULL,
    .available     = NULL,
    .speed_changed = NULL,
    .force_redraw  = NULL,
    .config        = wd8013epa_config
};
