/*      $NetBSD: if_qn.c,v 1.53 2022/09/17 19:23:24 thorpej Exp $ */

/*
 * Copyright (c) 1995 Mika Kortelainen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by  Mika Kortelainen
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Thanks for Aspecs Oy (Finland) for the data book for the NIC used
 * in this card and also many thanks for the Resource Management Force
 * (QuickNet card manufacturer) and especially Daniel Koch for providing
 * me with the necessary 'inside' information to write the driver.
 *
 * This is partly based on other code:
 * - if_ed.c: basic function structure for Ethernet driver and now also
 *      qn_put() is done similarly, i.e. no extra packet buffers.
 *
 *      Device driver for National Semiconductor DS8390/WD83C690 based ethernet
 *      adapters.
 *
 *      Copyright (c) 1994, 1995 Charles M. Hannum.  All rights reserved.
 *
 *      Copyright (C) 1993, David Greenman.  This software may be used,
 *      modified, copied, distributed, and sold, in both source and binary
 *      form provided that the above copyright and these terms are retained.
 *      Under no circumstances is the author responsible for the proper
 *      functioning of this software, nor does the author assume any
 *      responsibility for damages incurred with its use.
 *
 * - if_es.c: used as an example of -current driver
 *
 *      Copyright (c) 1995 Michael L. Hitch
 *      All rights reserved.
 *
 * - if_fe.c: some ideas for error handling for qn_rint() which might
 *      have fixed those random lock ups, too.
 *
 *      All Rights Reserved, Copyright (C) Fujitsu Limited 1995
 *
 *
 * TODO:
 * - add multicast support
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_qn.c,v 1.53 2022/09/17 19:23:24 thorpej Exp $");

#include "qn.h"
#if NQN > 0

#define QN_DEBUG
#define QN_DEBUG1_no /* hides some old tests */
#define QN_CHECKS_no /* adds some checks (not needed in normal situations) */


/*
 * Fujitsu MB86950 Ethernet Controller (as used in the QuickNet QN2000
 * Ethernet card)
 */

#include "opt_inet.h"
#include "opt_ns.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/buf.h>
#include <sys/device.h>
#include <sys/protosw.h>
#include <sys/socket.h>
#include <sys/syslog.h>
#include <sys/ioctl.h>
#include <sys/errno.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_ether.h>
#include <net/bpf.h>

#ifdef INET
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <netinet/if_inarp.h>
#endif

#include <machine/cpu.h>
#include <amiga/amiga/device.h>
#include <amiga/amiga/isr.h>
#include <amiga/dev/zbusvar.h>
#include <amiga/dev/if_qnreg.h>


#define NIC_R_MASK      (R_INT_PKT_RDY | R_INT_ALG_ERR |\
                         R_INT_CRC_ERR | R_INT_OVR_FLO)
#define MAX_PACKETS     30 /* max number of packets read per interrupt */

/*
 * Ethernet software status per interface
 *
 * Each interface is referenced by a network interface structure,
 * qn_if, which the routing code uses to locate the interface.
 * This structure contains the output queue for the interface, its address, ...
 */
struct  qn_softc {
        device_t sc_dev;
        struct  isr sc_isr;
        struct  ethercom sc_ethercom;   /* Common ethernet structures */
        u_char  volatile *sc_base;
        u_char  volatile *sc_nic_base;
        u_short volatile *nic_fifo;
        u_short volatile *nic_r_status;
        u_short volatile *nic_t_status;
        u_short volatile *nic_r_mask;
        u_short volatile *nic_t_mask;
        u_short volatile *nic_r_mode;
        u_short volatile *nic_t_mode;
        u_short volatile *nic_reset;
        u_short volatile *nic_len;
        bool    transmit_pending;
};

int     qnmatch(device_t, cfdata_t, void *);
void    qnattach(device_t, device_t, void *);
int     qnintr(void *);
int     qnioctl(struct ifnet *, u_long, void *);
void    qnstart(struct ifnet *);
void    qnwatchdog(struct ifnet *);
void    qnreset(struct qn_softc *);
void    qninit(struct qn_softc *);
void    qnstop(struct qn_softc *);
static  u_short qn_put(u_short volatile *, struct mbuf *);
static  void qn_rint(struct qn_softc *, u_short);
static  void qn_flush(struct qn_softc *);
static  void inline word_copy_from_card(u_short volatile *, u_short *, u_short);
static  void inline word_copy_to_card(u_short *, u_short volatile *,
                                register u_short);
static  void qn_get_packet(struct qn_softc *, u_short);
#ifdef QN_DEBUG1
static  void qn_dump(struct qn_softc *);
#endif

CFATTACH_DECL_NEW(qn, sizeof(struct qn_softc),
    qnmatch, qnattach, NULL, NULL);

int
qnmatch(device_t parent, cfdata_t cf, void *aux)
{
        struct zbus_args *zap;

        zap = (struct zbus_args *)aux;

        /* RMF QuickNet QN2000 EtherNet card */
        if (zap->manid == 2011 && zap->prodid == 2)
                return (1);

        return (0);
}

/*
 * Interface exists: make available by filling in network interface
 * record.  System will initialize the interface when it is ready
 * to accept packets.
 */
void
qnattach(device_t parent, device_t self, void *aux)
{
        struct zbus_args *zap;
        struct qn_softc *sc = device_private(self);
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        u_int8_t myaddr[ETHER_ADDR_LEN];

        sc->sc_dev = self;
        zap = (struct zbus_args *)aux;

        sc->sc_base = zap->va;
        sc->sc_nic_base = sc->sc_base + QUICKNET_NIC_BASE;
        sc->nic_fifo = (u_short volatile *)(sc->sc_nic_base + NIC_BMPR0);
        sc->nic_len = (u_short volatile *)(sc->sc_nic_base + NIC_BMPR2);
        sc->nic_t_status = (u_short volatile *)(sc->sc_nic_base + NIC_DLCR0);
        sc->nic_r_status = (u_short volatile *)(sc->sc_nic_base + NIC_DLCR2);
        sc->nic_t_mask = (u_short volatile *)(sc->sc_nic_base + NIC_DLCR1);
        sc->nic_r_mask = (u_short volatile *)(sc->sc_nic_base + NIC_DLCR3);
        sc->nic_t_mode = (u_short volatile *)(sc->sc_nic_base + NIC_DLCR4);
        sc->nic_r_mode = (u_short volatile *)(sc->sc_nic_base + NIC_DLCR5);
        sc->nic_reset = (u_short volatile *)(sc->sc_nic_base + NIC_DLCR6);
        sc->transmit_pending = false;

        /*
         * The ethernet address of the board (1st three bytes are the vendor
         * address, the rest is the serial number of the board).
         */
        myaddr[0] = 0x5c;
        myaddr[1] = 0x5c;
        myaddr[2] = 0x00;
        myaddr[3] = (zap->serno >> 16) & 0xff;
        myaddr[4] = (zap->serno >> 8) & 0xff;
        myaddr[5] = zap->serno & 0xff;

        /* set interface to stopped condition (reset) */
        qnstop(sc);

        memcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
        ifp->if_softc = sc;
        ifp->if_ioctl = qnioctl;
        ifp->if_watchdog = qnwatchdog;
        ifp->if_start = qnstart;
        /* XXX IFF_MULTICAST */
        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
        ifp->if_mtu = ETHERMTU;

        /* Attach the interface. */
        if_attach(ifp);
        if_deferred_start_init(ifp, NULL);
        ether_ifattach(ifp, myaddr);

#ifdef QN_DEBUG
        printf(": hardware address %s\n", ether_sprintf(myaddr));
#endif

        sc->sc_isr.isr_intr = qnintr;
        sc->sc_isr.isr_arg = sc;
        sc->sc_isr.isr_ipl = 2;
        add_isr(&sc->sc_isr);
}

/*
 * Initialize device
 *
 */
void
qninit(struct qn_softc *sc)
{
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        u_short i;
        static int retry = 0;

        *sc->nic_r_mask   = NIC_R_MASK;
        *sc->nic_t_mode   = NO_LOOPBACK;

        if (sc->sc_ethercom.ec_if.if_flags & IFF_PROMISC) {
                *sc->nic_r_mode = PROMISCUOUS_MODE;
                log(LOG_INFO, "qn: Promiscuous mode (not tested)\n");
        } else
                *sc->nic_r_mode = NORMAL_MODE;

        /* Set physical ethernet address. */
        for (i = 0; i < ETHER_ADDR_LEN; i++)
                *((u_short volatile *)(sc->sc_nic_base+
                                       QNET_HARDWARE_ADDRESS+2*i)) =
                    ((((u_short)CLLADDR(ifp->if_sadl)[i]) << 8) |
                    CLLADDR(ifp->if_sadl)[i]);

        ifp->if_flags |= IFF_RUNNING;
        sc->transmit_pending = false;

        qn_flush(sc);

        /* QuickNet magic. Done ONLY once, otherwise a lockup occurs. */
        if (retry == 0) {
                *((u_short volatile *)(sc->sc_nic_base + QNET_MAGIC)) = 0;
                retry = 1;
        }

        /* Enable data link controller. */
        *sc->nic_reset = ENABLE_DLC;

        /* Attempt to start output, if any. */
        if_schedule_deferred_start(ifp);
}

/*
 * Device timeout/watchdog routine.  Entered if the device neglects to
 * generate an interrupt after a transmit has been started on it.
 */
void
qnwatchdog(struct ifnet *ifp)
{
        struct qn_softc *sc = ifp->if_softc;

        log(LOG_INFO, "qn: device timeout (watchdog)\n");
        if_statinc(ifp, if_oerrors);

        qnreset(sc);
}

/*
 * Flush card's buffer RAM.
 */
static void
qn_flush(struct qn_softc *sc)
{
#if 1
        /* Read data until bus read error (i.e. buffer empty). */
        while (!(*sc->nic_r_status & R_BUS_RD_ERR))
                (void)(*sc->nic_fifo);
#else
        /* Read data twice to clear some internal pipelines. */
        (void)(*sc->nic_fifo);
        (void)(*sc->nic_fifo);
#endif

        /* Clear bus read error. */
        *sc->nic_r_status = R_BUS_RD_ERR;
}

/*
 * Reset the interface.
 *
 */
void
qnreset(struct qn_softc *sc)
{
        int s;

        s = splnet();
        qnstop(sc);
        qninit(sc);
        splx(s);
}

/*
 * Take interface offline.
 */
void
qnstop(struct qn_softc *sc)
{

        /* Stop the interface. */
        *sc->nic_reset    = DISABLE_DLC;
        delay(200);
        *sc->nic_t_status = CLEAR_T_ERR;
        *sc->nic_t_mask   = CLEAR_T_MASK;
        *sc->nic_r_status = CLEAR_R_ERR;
        *sc->nic_r_mask   = CLEAR_R_MASK;

        /* Turn DMA off */
        *((u_short volatile *)(sc->sc_nic_base + NIC_BMPR4)) = 0;

        /* Accept no packets. */
        *sc->nic_r_mode = 0;
        *sc->nic_t_mode = 0;

        qn_flush(sc);
}

/*
 * Start output on interface. Get another datagram to send
 * off the interface queue, and copy it to the
 * interface before starting the output.
 *
 * This assumes that it is called inside a critical section...
 *
 */
void
qnstart(struct ifnet *ifp)
{
        struct qn_softc *sc = ifp->if_softc;
        struct mbuf *m;
        u_short len;
        int timout = 60000;


        if ((ifp->if_flags & IFF_RUNNING) == 0)
                return;

        if (sc->transmit_pending)
                return;

        IF_DEQUEUE(&ifp->if_snd, m);
        if (m == 0)
                return;

        /*
         * If bpf is listening on this interface, let it
         * see the packet before we commit it to the wire
         *
         * (can't give the copy in QuickNet card RAM to bpf, because
         * that RAM is not visible to the host but is read from FIFO)
         */
        bpf_mtap(ifp, m, BPF_D_OUT);
        len = qn_put(sc->nic_fifo, m);
        m_freem(m);

        /*
         * Really transmit the packet.
         */

        /* Set packet length (byte-swapped). */
        len = ((len >> 8) & 0x0007) | TRANSMIT_START | ((len & 0x00ff) << 8);
        *sc->nic_len = len;

        /* Wait for the packet to really leave. */
        while (!(*sc->nic_t_status & T_TMT_OK) && --timout) {
                if ((timout % 10000) == 0)
                        log(LOG_INFO, "qn: timeout...\n");
        }

        if (timout == 0)
                /* Maybe we should try to recover from this one? */
                /* But now, let's just fall thru and hope the best... */
                log(LOG_INFO, "qn: transmit timeout (fatal?)\n");

        sc->transmit_pending = true;
        *sc->nic_t_mask = INT_TMT_OK | INT_SIXTEEN_COL;

        ifp->if_timer = 2;
}

/*
 * Memory copy, copies word at a time
 */
static void inline
word_copy_from_card(u_short volatile *card, u_short *b, u_short len)
{
        register u_short l = len/2;

        while (l--)
                *b++ = *card;
}

static void inline
word_copy_to_card(u_short *a, u_short volatile *card, register u_short len)
{
        /*register u_short l = len/2;*/

        while (len--)
                *card = *a++;
}

/*
 * Copy packet from mbuf to the board memory
 *
 */
static u_short
qn_put(u_short volatile *addr, struct mbuf *m)
{
        u_short *data;
        u_char savebyte[2];
        int len, len1, wantbyte;
        u_short totlen;

        totlen = wantbyte = 0;

        for (; m != NULL; m = m->m_next) {
                data = mtod(m, u_short *);
                len = m->m_len;
                if (len > 0) {
                        totlen += len;

                        /* Finish the last word. */
                        if (wantbyte) {
                                savebyte[1] = *((u_char *)data);
                                *addr = *((u_short *)savebyte);
                                data = (u_short *)((u_char *)data + 1);
                                len--;
                                wantbyte = 0;
                        }
                        /* Output contiguous words. */
                        if (len > 1) {
                                len1 = len/2;
                                word_copy_to_card(data, addr, len1);
                                data += len1;
                                len &= 1;
                        }
                        /* Save last byte, if necessary. */
                        if (len == 1) {
                                savebyte[0] = *((u_char *)data);
                                wantbyte = 1;
                        }
                }
        }

        if (wantbyte) {
                savebyte[1] = 0;
                *addr = *((u_short *)savebyte);
        }

        if(totlen < (ETHER_MIN_LEN - ETHER_CRC_LEN)) {
                /*
                 * Fill the rest of the packet with zeros.
                 * N.B.: This is required! Otherwise MB86950 fails.
                 */
                for(len = totlen + 1; len < (ETHER_MIN_LEN - ETHER_CRC_LEN);
                    len += 2)
                        *addr = (u_short)0x0000;
                totlen = (ETHER_MIN_LEN - ETHER_CRC_LEN);
        }

        return (totlen);
}

/*
 * Copy packet from board RAM.
 *
 * Trailers not supported.
 *
 */
static void
qn_get_packet(struct qn_softc *sc, u_short len)
{
        register u_short volatile *nic_fifo_ptr = sc->nic_fifo;
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        struct mbuf *m, *dst, *head = NULL;
        register u_short len1;
        u_short amount;

        /* Allocate header mbuf. */
        MGETHDR(m, M_DONTWAIT, MT_DATA);
        if (m == NULL)
                goto bad;

        /*
         * Round len to even value.
         */
        if (len & 1)
                len++;

        m_set_rcvif(m, &sc->sc_ethercom.ec_if);
        m->m_pkthdr.len = len;
        m->m_len = 0;
        head = m;

        word_copy_from_card(nic_fifo_ptr,
            mtod(head, u_short *),
            sizeof(struct ether_header));

        head->m_len += sizeof(struct ether_header);
        len -= sizeof(struct ether_header);

        while (len > 0) {
                len1 = len;

                amount = M_TRAILINGSPACE(m);
                if (amount == 0) {
                        /* Allocate another mbuf. */
                        dst = m;
                        MGET(m, M_DONTWAIT, MT_DATA);
                        if (m == NULL)
                                goto bad;

                        if (len1 >= MINCLSIZE)
                                MCLGET(m, M_DONTWAIT);

                        m->m_len = 0;
                        dst->m_next = m;

                        amount = M_TRAILINGSPACE(m);
                }

                if (amount < len1)
                        len1 = amount;

                word_copy_from_card(nic_fifo_ptr,
                    (u_short *)(mtod(m, char *) + m->m_len),
                    len1);
                m->m_len += len1;
                len -= len1;
        }

        if_percpuq_enqueue(ifp->if_percpuq, head);
        return;

bad:
        if (head) {
                m_freem(head);
                log(LOG_INFO, "qn_get_packet: mbuf alloc failed\n");
        }
}

/*
 * Ethernet interface receiver interrupt.
 */
static void
qn_rint(struct qn_softc *sc, u_short rstat)
{
        int i;
        u_short len, status;

        /* Clear the status register. */
        *sc->nic_r_status = CLEAR_R_ERR;

        /*
         * Was there some error?
         * Some of them are senseless because they are masked off.
         * XXX
         */
        if (rstat & R_INT_OVR_FLO) {
#ifdef QN_DEBUG
                log(LOG_INFO, "Overflow\n");
#endif
                if_statinc(&sc->sc_ethercom.ec_if, if_ierrors);
        }
        if (rstat & R_INT_CRC_ERR) {
#ifdef QN_DEBUG
                log(LOG_INFO, "CRC Error\n");
#endif
                if_statinc(&sc->sc_ethercom.ec_if, if_ierrors);
        }
        if (rstat & R_INT_ALG_ERR) {
#ifdef QN_DEBUG
                log(LOG_INFO, "Alignment error\n");
#endif
                if_statinc(&sc->sc_ethercom.ec_if, if_ierrors);
        }
        if (rstat & R_INT_SRT_PKT) {
                /* Short packet (these may occur and are
                 * no reason to worry about - or maybe
                 * they are?).
                 */
#ifdef QN_DEBUG
                log(LOG_INFO, "Short packet\n");
#endif
                if_statinc(&sc->sc_ethercom.ec_if, if_ierrors);
        }
        if (rstat & 0x4040) {
#ifdef QN_DEBUG
                log(LOG_INFO, "Bus read error\n");
#endif
                if_statinc(&sc->sc_ethercom.ec_if, if_ierrors);
                qnreset(sc);
        }

        /*
         * Read at most MAX_PACKETS packets per interrupt
         */
        for (i = 0; i < MAX_PACKETS; i++) {
                if (*sc->nic_r_mode & RM_BUF_EMP)
                        /* Buffer empty. */
                        break;

                /*
                 * Read the first word: upper byte contains useful
                 * information.
                 */
                status = *sc->nic_fifo;
                if ((status & 0x7000) != 0x2000) {
                        log(LOG_INFO, "qn: ERROR: status=%04x\n", status);
                        continue;
                }

                /*
                 * Read packet length (byte-swapped).
                 * CRC is stripped off by the NIC.
                 */
                len = *sc->nic_fifo;
                len = ((len << 8) & 0xff00) | ((len >> 8) & 0x00ff);

#ifdef QN_CHECKS
                if (len > (ETHER_MAX_LEN - ETHER_CRC_LEN) ||
                    len < ETHER_HDR_LEN) {
                        log(LOG_WARNING,
                            "%s: received a %s packet? (%u bytes)\n",
                            device_xname(sc->sc_dev),
                            len < ETHER_HDR_LEN ? "partial" : "big", len);
                        if_statinc(&sc->sc_ethercom.ec_if, if_ierrors);
                        continue;
                }
#endif
#ifdef QN_CHECKS
                if (len < (ETHER_MIN_LEN - ETHER_CRC_LEN))
                        log(LOG_WARNING,
                            "%s: received a short packet? (%u bytes)\n",
                            device_xname(sc->sc_dev), len);
#endif

                /* Read the packet. */
                qn_get_packet(sc, len);
        }

#ifdef QN_DEBUG
        /* This print just to see whether MAX_PACKETS is large enough. */
        if (i == MAX_PACKETS)
                log(LOG_INFO, "used all the %d loops\n", MAX_PACKETS);
#endif
}

/*
 * Our interrupt routine
 */
int
qnintr(void *arg)
{
        struct qn_softc *sc = arg;
        u_short tint, rint, tintmask;
        char return_tintmask = 0;

        /*
         * If the driver has not been initialized, just return immediately.
         * This also happens if there is no QuickNet board present.
         */
        if (sc->sc_base == NULL)
                return (0);

        /* Get interrupt statuses and masks. */
        rint = (*sc->nic_r_status) & NIC_R_MASK;
        tintmask = *sc->nic_t_mask;
        tint = (*sc->nic_t_status) & tintmask;
        if (tint == 0 && rint == 0)
                return (0);

        /* Disable interrupts so that we won't miss anything. */
        *sc->nic_r_mask = CLEAR_R_MASK;
        *sc->nic_t_mask = CLEAR_T_MASK;

        /*
         * Handle transmitter interrupts. Some of them are not asked for
         * but do happen, anyway.
         */

        if (tint != 0) {
                /* Clear transmit interrupt status. */
                *sc->nic_t_status = CLEAR_T_ERR;

                if (sc->transmit_pending && (tint & T_TMT_OK)) {
                        sc->transmit_pending = false;
                        /*
                         * Update total number of successfully
                         * transmitted packets.
                         */
                        if_statinc(&sc->sc_ethercom.ec_if, if_opackets);
                }

                if (tint & T_SIXTEEN_COL) {
                        /*
                         * 16 collision (i.e., packet lost).
                         */
                        log(LOG_INFO, "qn: 16 collision - packet lost\n");
#ifdef QN_DEBUG1
                        qn_dump(sc);
#endif
                        if_statadd2(&sc->sc_ethercom.ec_if,
                            if_oerrors, 1, if_collisions, 16);
                        sc->transmit_pending = false;
                }

                if (sc->transmit_pending) {
                        log(LOG_INFO, "qn:still pending...\n");

                        /* Must return transmission interrupt mask. */
                        return_tintmask = 1;
                } else {
                        /* Clear watchdog timer. */
                        sc->sc_ethercom.ec_if.if_timer = 0;
                }
        } else
                return_tintmask = 1;

        /*
         * Handle receiver interrupts.
         */
        if (rint != 0)
                qn_rint(sc, rint);

        if (!sc->transmit_pending)
                if_schedule_deferred_start(&sc->sc_ethercom.ec_if);
        else if (return_tintmask == 1)
                *sc->nic_t_mask = tintmask;

        /* Set receive interrupt mask back. */
        *sc->nic_r_mask = NIC_R_MASK;

        return (1);
}

/*
 * Process an ioctl request. This code needs some work - it looks pretty ugly.
 * I somehow think that this is quite a common excuse... ;-)
 */
int
qnioctl(register struct ifnet *ifp, u_long cmd, void *data)
{
        struct qn_softc *sc = ifp->if_softc;
        register struct ifaddr *ifa = (struct ifaddr *)data;
#if 0
        struct ifreg *ifr = (struct ifreg *)data;
#endif
        int s, error = 0;

        s = splnet();

        switch (cmd) {

        case SIOCINITIFADDR:
                ifp->if_flags |= IFF_UP;

                switch (ifa->ifa_addr->sa_family) {
#ifdef INET
                case AF_INET:
                        qnstop(sc);
                        qninit(sc);
                        arp_ifinit(ifp, ifa);
                        break;
#endif
                default:
                        log(LOG_INFO, "qn:sa_family:default (not tested)\n");
                        qnstop(sc);
                        qninit(sc);
                        break;
                }
                break;

        case SIOCSIFFLAGS:
                if ((error = ifioctl_common(ifp, cmd, data)) != 0)
                        break;
                /* XXX see the comment in ed_ioctl() about code re-use */
                if ((ifp->if_flags & IFF_UP) == 0 &&
                    (ifp->if_flags & IFF_RUNNING) != 0) {
                        /*
                         * If interface is marked down and it is running, then
                         * stop it.
                         */
#ifdef QN_DEBUG1
                        qn_dump(sc);
#endif
                        qnstop(sc);
                        ifp->if_flags &= ~IFF_RUNNING;
                } else if ((ifp->if_flags & IFF_UP) != 0 &&
                           (ifp->if_flags & IFF_RUNNING) == 0) {
                        /*
                         * If interface is marked up and it is stopped, then
                         * start it.
                         */
                        qninit(sc);
                } else {
                        /*
                         * Something else... we won't do anything so we won't
                         * break anything (hope so).
                         */
#ifdef QN_DEBUG1
                        log(LOG_INFO, "Else branch...\n");
#endif
                }
                break;

        case SIOCADDMULTI:
        case SIOCDELMULTI:
                log(LOG_INFO, "qnioctl: multicast not done yet\n");
#if 0
                if ((error = ether_ioctl(ifp, cmd, data)) == ENETRESET) {
                        /*
                         * Multicast list has changed; set the hardware filter
                         * accordingly.
                         */
                        log(LOG_INFO, "qnioctl: multicast not done yet\n");
                        error = 0;
                }
#else
                error = EINVAL;
#endif
                break;

        default:
                error = ether_ioctl(ifp, cmd, data);
        }

        splx(s);
        return (error);
}

/*
 * Dump some register information.
 */
#ifdef QN_DEBUG1
static void
qn_dump(struct qn_softc *sc)
{

        log(LOG_INFO, "t_status  : %04x\n", *sc->nic_t_status);
        log(LOG_INFO, "t_mask    : %04x\n", *sc->nic_t_mask);
        log(LOG_INFO, "t_mode    : %04x\n", *sc->nic_t_mode);
        log(LOG_INFO, "r_status  : %04x\n", *sc->nic_r_status);
        log(LOG_INFO, "r_mask    : %04x\n", *sc->nic_r_mask);
        log(LOG_INFO, "r_mode    : %04x\n", *sc->nic_r_mode);
        log(LOG_INFO, "pending   : %s\n", sc->transmit_pending ? "T" : "F");
        log(LOG_INFO, "if_flags  : %04x\n", sc->sc_ethercom.ec_if.if_flags);
}
#endif

#endif /* NQN > 0 */