/*
 * upf_usbgem.c : ADMtek an986/adm8511/adm8513/adm8515 USB to
 * Fast Ethernet Driver for Solaris
 */

/*
 * Copyright (c) 2004-2011 Masayuki Murayama.  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. Neither the name of the author nor the names of its contributors may be
 *    used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "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
 * COPYRIGHT OWNER OR CONTRIBUTORS 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.
 */

/*
 *  Changelog:
 */

/*
 * TODO
 */
/* ======================================================= */

/*
 * Solaris system header files and macros
 */
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/debug.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/errno.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/byteorder.h>

/* ethernet stuff */
#include <sys/ethernet.h>

/* interface card depend stuff */
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/strlog.h>
#include <sys/usb/usba.h>
#include "usbgem.h"

/* hardware stuff */
#include "usbgem_mii.h"
#include "adm8511reg.h"

char    ident[] = "pegasus usbnic driver v" VERSION;

/*
 * Useful macros
 */
#define CHECK_AND_JUMP(val, label)      \
        if ((val) != USB_SUCCESS) { goto label; }

/*
 * Debugging
 */
#ifdef DEBUG_LEVEL
static int upf_debug = DEBUG_LEVEL;
#define DPRINTF(n, args)        if (upf_debug > (n)) cmn_err args
#else
#define DPRINTF(n, args)
#endif

/*
 * Our configration for ADMtek Pegasus/PegasusII
 */
/* timeouts */
#define ONESEC          (drv_usectohz(1*1000000))

/*
 * Local device definitions
 */
struct upf_dev {
        /*
         * Misc HW information
         */
        uint8_t         ec[3];
        uint8_t         mac_addr[ETHERADDRL];
        int             chip_type;
#define CHIP_AN986      1       /* avoid 0 */
#define CHIP_ADM8511    2       /* including adm8515 */
#define CHIP_ADM8513    3
        boolean_t       phy_init_done;
        uint8_t         last_link_state;

        uint16_t        vid;    /* vendor id */
        uint16_t        pid;    /* product id */
};

/*
 * private functions
 */

/* mii operations */
static uint16_t upf_mii_read(struct usbgem_dev *, uint_t, int *errp);
static void upf_mii_write(struct usbgem_dev *, uint_t, uint16_t, int *errp);

/* nic operations */
static int upf_attach_chip(struct usbgem_dev *);
static int upf_reset_chip(struct usbgem_dev *);
static int upf_init_chip(struct usbgem_dev *);
static int upf_start_chip(struct usbgem_dev *);
static int upf_stop_chip(struct usbgem_dev *);
static int upf_set_media(struct usbgem_dev *);
static int upf_set_rx_filter(struct usbgem_dev *);
static int upf_get_stats(struct usbgem_dev *);

/* packet operations */
static mblk_t *upf_tx_make_packet(struct usbgem_dev *, mblk_t *);
static mblk_t *upf_rx_make_packet(struct usbgem_dev *, mblk_t *);

/* interrupt handler */
static void upf_interrupt(struct usbgem_dev *, mblk_t *);

/* =============================================================== */
/*
 * I/O functions
 */
/* =============================================================== */
#define UPF_REQ_GET_REGISTER    0xf0
#define UPF_REQ_SET_REGISTER    0xf1
#define OUTB(dp, p, v, errp, label)     \
        if ((*(errp) = usbgem_ctrl_out((dp),    \
        /* bmRequestType */ USB_DEV_REQ_HOST_TO_DEV     \
                | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,       \
        /* bRequest */  UPF_REQ_SET_REGISTER,   \
        /* wValue */    (v),    \
        /* wIndex */    (p),    \
        /* wLength */   1,      \
        /* buf */       NULL,   \
        /* size */      0)) != USB_SUCCESS) goto label;

#define OUTW(dp, p, v, errp, label)     \
        if ((*(errp) = usbgem_ctrl_out_val((dp),        \
        /* bmRequestType */ USB_DEV_REQ_HOST_TO_DEV     \
                | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,       \
        /* bRequest */  UPF_REQ_SET_REGISTER,   \
        /* wValue */    0,      \
        /* wIndex */    (p),    \
        /* wLength */   2,      \
        /* value */     (v))) != USB_SUCCESS) goto label

#define OUTS(dp, p, buf, len, errp, label)      \
        if ((*(errp) = usbgem_ctrl_out((dp),    \
        /* bmRequestType */ USB_DEV_REQ_HOST_TO_DEV     \
                | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,       \
        /* bRequest */  UPF_REQ_SET_REGISTER,   \
        /* wValue */    0,      \
        /* wIndex */    (p),    \
        /* wLength */   (len),  \
        /* buf */       (buf),  \
        /* size */      (len))) != USB_SUCCESS) goto label

#define INB(dp, p, vp, errp, label)     \
        if ((*(errp) = usbgem_ctrl_in_val((dp),         \
        /* bmRequestType */ USB_DEV_REQ_DEV_TO_HOST     \
                | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,       \
        /* bRequest */ UPF_REQ_GET_REGISTER,    \
        /* wValue */    0,      \
        /* wIndex */    (p),    \
        /* wLength */   1,      \
        /* valuep */    (vp))) != USB_SUCCESS) goto label

#define INW(dp, p, vp, errp, label)     \
        if ((*(errp) = usbgem_ctrl_in_val((dp),         \
        /* bmRequestType */ USB_DEV_REQ_DEV_TO_HOST     \
                | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,       \
        /* bRequest */ UPF_REQ_GET_REGISTER,    \
        /* wValue */    0,      \
        /* wIndex */    (p),    \
        /* wLength */   2,      \
        /* valuep */    (vp))) != USB_SUCCESS) goto label

#define INS(dp, p, buf, len, errp, label)       \
        if ((*(errp) = usbgem_ctrl_in((dp),     \
        /* bmRequestType */ USB_DEV_REQ_DEV_TO_HOST     \
                    | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,   \
        /* bRequest */ UPF_REQ_GET_REGISTER,    \
        /* wValue */    0,      \
        /* wIndex */    (p),    \
        /* wLength */   (len),  \
        /* buf */       (buf),  \
        /* size */      (len))) != USB_SUCCESS) goto label

/* =============================================================== */
/*
 * Hardware manupilation
 */
/* =============================================================== */
static int
upf_reset_chip(struct usbgem_dev *dp)
{
        int             i;
        uint8_t         val;
        int             err;
        struct upf_dev  *lp = dp->private;

        DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));
        bzero(lp->mac_addr, sizeof (lp->mac_addr));

        lp->ec[1] = 0;
        OUTB(dp, EC1, EC1_RM, &err, usberr);

        for (i = 0; i < 1000; i++) {
                INB(dp, EC1, &val, &err, usberr);
                if ((val & EC1_RM) == 0) {
                        lp->ec[1] = val;
                        return (USB_SUCCESS);
                }
                drv_usecwait(10);
        }

        /* time out */
        cmn_err(CE_WARN, "!%s: failed to reset: timeout", dp->name);
        return (USB_FAILURE);

usberr:
        cmn_err(CE_NOTE, "!%s: %s: usberr detected", dp->name, __func__);
        return (USB_FAILURE);
}

/*
 * Setup an986/adm8511/adm8513/adm8515
 */
static int
upf_init_chip(struct usbgem_dev *dp)
{
        uint64_t        zero64 = 0;
        int     err = USB_SUCCESS;
        struct upf_dev  *lp = dp->private;

        DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));

        /* ethernet control register 0 */
        lp->ec[0] |= EC0_RXSA | EC0_RXCS;
        OUTB(dp, EC0, lp->ec[0], &err, usberr);

        /* ethernet control reg1: will be set later in set_rx_filter() */

        /* ethernet control register 2: will be set later in set_rx_filter() */
        INB(dp, EC2, &lp->ec[2], &err, usberr);
        lp->ec[2] |= EC2_RXBP | EC2_EP3RC;
#ifdef CONFIG_VLAN
        if (dp->misc_flag & USBGEM_VLAN) {
                lp->ec[2] |= EC2_MEPL;
        }
#endif
        OUTB(dp, EC2, lp->ec[2], &err, usberr);

        /* Multicast address hash: clear */
        OUTS(dp, MA, &zero64, 8, &err, usberr);

        /* Ethernet ID : will be set later in upf_set_rx_filter() */

        /* PAUSE timer */
        OUTB(dp, PAUSETIMER, 0x1f, &err, usberr);

        /* receive packet number based pause control:set in upf_set_media() */

        /* occupied receive FIFO based pause control:set in upf_set_media() */

        /* EP1 control: default */

        /* Rx FIFO control */
        if (lp->chip_type != CHIP_AN986) {
                /* use 24K internal sram, 16pkts in fifo */
                OUTB(dp, RXFC, 0, &err, usberr);
        }

        /* BIST contror: do nothing */
        err = upf_set_media(dp);
        CHECK_AND_JUMP(err, usberr);

        DPRINTF(2, (CE_CONT, "!%s: %s: end (success)", dp->name, __func__));
        return (USB_SUCCESS);

usberr:
        cmn_err(CE_NOTE, "!%s: %s: usberr(%d) detected",
            dp->name, __func__, err);
        return (err);
}

static int
upf_start_chip(struct usbgem_dev *dp)
{
        int     err = USB_SUCCESS;
        struct upf_dev  *lp = dp->private;

        DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));

        /* enable RX and TX */
        lp->ec[0] |= EC0_TXE | EC0_RXE;
        OUTB(dp, EC0, lp->ec[0], &err, usberr);
        return (USB_SUCCESS);

usberr:
        cmn_err(CE_WARN, "!%s: %s: usberr(%d) detected",
            dp->name, __func__, err);
        return (err);
}

static int
upf_stop_chip(struct usbgem_dev *dp)
{
        int     err;
        struct upf_dev  *lp = dp->private;

        DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));

        /* disable RX and TX */
        lp->ec[0] &= ~(EC0_TXE | EC0_RXE);
        OUTB(dp, EC0, lp->ec[0], &err, usberr);

        return (USB_SUCCESS);

usberr:
        cmn_err(CE_WARN, "!%s: %s: usberr(%d) detected",
            dp->name, __func__, err);
        return (err);
}

static int
upf_get_stats(struct usbgem_dev *dp)
{
        /* do nothing */
        return (USB_SUCCESS);
}

static uint_t
upf_mcast_hash(struct usbgem_dev *dp, const uint8_t *addr)
{
        /* hash table is 64 = 2^6 bit width */
        return (usbgem_ether_crc_le(addr) & 0x3f);
}

static int
upf_set_rx_filter(struct usbgem_dev *dp)
{
        int             i;
        int             err;
#ifdef DEBUG_LEVEL
        uint8_t         reg0;
        uint8_t         reg1;
        uint8_t         reg2;
#endif
        struct upf_dev  *lp = dp->private;

        DPRINTF(0, (CE_CONT, "!%s: %s: called, rxmode:%b",
            dp->name, __func__, dp->rxmode, RXMODE_BITS));

        /* reset rx mode */
        lp->ec[0] &= ~EC0_RXMA;
        lp->ec[2] &= ~EC2_PROM;

        if (dp->rxmode & RXMODE_PROMISC) {
                /* promiscious mode implies all multicast and all physical */
                lp->ec[0] |= EC0_RXMA;
                lp->ec[2] |= EC2_PROM;
        } else if ((dp->rxmode & RXMODE_ALLMULTI) || dp->mc_count > 0) {
                /* XXX - multicast hash table didin't work */
                /* accept all multicast packets */
                lp->ec[0] |= EC0_RXMA;
        }

        if (bcmp(dp->cur_addr.ether_addr_octet,
            lp->mac_addr, ETHERADDRL) != 0) {

                /* need to update mac address */
                bcopy(dp->cur_addr.ether_addr_octet,
                    lp->mac_addr, ETHERADDRL);
                OUTS(dp, EID,
                    lp->mac_addr, ETHERADDRL, &err, usberr);
        }

        /* update rx mode */
        OUTS(dp, EC0, lp->ec, 3, &err, usberr);

#if DEBUG_LEVEL > 0
        INB(dp, EC0, &reg0, &err, usberr);
        INB(dp, EC1, &reg1, &err, usberr);
        INB(dp, EC2, &reg2, &err, usberr);

        cmn_err(CE_CONT, "!%s: %s: returned, ec:%b %b %b",
            dp->name, __func__,
            reg0, EC0_BITS, reg1, EC1_BITS, reg2, EC2_BITS);
#endif
        return (USB_SUCCESS);

usberr:
        cmn_err(CE_NOTE, "!%s: %s: usberr detected", dp->name, __func__);
        return (err);
}

static int
upf_set_media(struct usbgem_dev *dp)
{
        int     err;
        struct upf_dev  *lp = dp->private;

        DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));

        lp->ec[1] &= ~(EC1_FD | EC1_100M);

        /* select duplex */
        if (dp->full_duplex) {
                lp->ec[1] |= EC1_FD;
        }

        /* select speed */
        if (dp->speed == USBGEM_SPD_100) {
                lp->ec[1] |= EC1_100M;
        }

        /* rx flow control */
        switch (dp->flow_control) {
        case FLOW_CONTROL_SYMMETRIC:
        case FLOW_CONTROL_RX_PAUSE:
                lp->ec[0] |= EC0_RXFCE;
                break;

        default:
                lp->ec[0] &= ~EC0_RXFCE;
                break;
        }

        /* tx flow control */
        switch (dp->flow_control) {
        case FLOW_CONTROL_SYMMETRIC:
        case FLOW_CONTROL_TX_PAUSE:
                if (lp->chip_type != CHIP_AN986) {
                        /* pegasus II has internal 24k fifo */
                        OUTB(dp, ORFBFC,
                            (12 << ORFBFC_RXS_SHIFT) |  ORFBFC_FCRXS,
                            &err, usberr);

                        /* 16 packts can be stored in rx fifo */
                        OUTB(dp, RPNBFC_PN,
                            (8 << RPNBFC_PN_SHIFT) |  RPNBFC_FCP,
                            &err, usberr);
                } else {
                        /* an986 has external 32k fifo */
                        OUTB(dp, ORFBFC,
                            (16 << ORFBFC_RXS_SHIFT) |  ORFBFC_FCRXS,
                            &err, usberr);

                        /* AN986 fails to link up when RPNBFC is enabled */
                        OUTB(dp, RPNBFC, 0, &err, usberr);
                }
                break;

        default:
                OUTB(dp, ORFBFC, 0, &err, usberr);
                OUTB(dp, RPNBFC, 0, &err, usberr);
                break;
        }

        /* update ether control registers */
        OUTS(dp, EC0, lp->ec, 2, &err, usberr);
        DPRINTF(0, (CE_CONT, "!%s: %s: returned, ec0:%b, ec1:%b",
            dp->name, __func__, lp->ec[0], EC0_BITS, lp->ec[1], EC1_BITS));

        return (USB_SUCCESS);

usberr:
        cmn_err(CE_WARN, "%s: %s: failed to write ec1", dp->name, __func__);
        return (err);
}

/*
 * send/receive packet check
 */
static mblk_t *
upf_tx_make_packet(struct usbgem_dev *dp, mblk_t *mp)
{
        size_t          len;
        mblk_t          *new;
        mblk_t          *tp;
        uint8_t         *bp;
        uint8_t         *last_pos;
        int             msglen;

        DPRINTF(3, (CE_CONT, "!%s: %s: called", dp->name, __func__));

        len = msgdsize(mp);
        if (len < ETHERMIN) {
                len = ETHERMIN;
        }

        /* allocate msg block */
        msglen = len + sizeof (uint16_t);

        /* avoid usb controller bug */
        if ((msglen & 0x3f) == 0) {
                /* add a header for additional 0-length usb message */
                msglen += sizeof (uint16_t);
        }

        if ((new = allocb(msglen, 0)) == NULL) {
                return (NULL);
        }

        /* copy contents of the buffer */
        new->b_wptr = new->b_rptr + msglen;
        bp = new->b_rptr;

        /* the nic requires a two byte header of the packet size */
        bp[0] = (uint8_t)len;
        bp[1] = (uint8_t)(len >> 8);
        bp += sizeof (uint16_t);

        /* copy the payload */
        for (tp = mp; tp; tp = tp->b_cont) {
                len = (uintptr_t)tp->b_wptr - (uintptr_t)tp->b_rptr;
                if (len > 0) {
                        bcopy(tp->b_rptr, bp, len);
                        bp += len;
                }
        }

        /* clear ethernet pads and additional usb header if we have */
        last_pos = new->b_wptr;
        while (bp < last_pos) {
                *bp++ = 0;
        }

        return (new);
}

static void
upf_dump_packet(struct usbgem_dev *dp, uint8_t *bp, int n)
{
        int     i;

        for (i = 0; i < n; i += 8, bp += 8) {
                cmn_err(CE_CONT, "%02x %02x %02x %02x %02x %02x %02x %02x",
                    bp[0], bp[1], bp[2], bp[3], bp[4], bp[5], bp[6], bp[7]);
        }
}

static mblk_t *
upf_rx_make_packet(struct usbgem_dev *dp, mblk_t *mp)
{
        uint8_t         *p;
        uint16_t        rxhd;
        uint_t          len;
        uint8_t         rsr;
        struct upf_dev  *lp = dp->private;

        ASSERT(mp != NULL);

#ifdef DEBUG_LEVEL
        len = msgdsize(mp);
        DPRINTF(2, (CE_CONT, "!%s: time:%d %s: cont:%p",
            dp->name, ddi_get_lbolt(), __func__, len, mp->b_cont));

        if (upf_debug > 3) {
                upf_dump_packet(dp, mp->b_rptr, max(6, len));
        }
#endif
        /* get the length of Rx packet */
        p = mp->b_wptr - 4;
        rsr = p[3];
        if (lp->chip_type == CHIP_ADM8513) {
                /* As Rx packets from ADM8513 have two byte header, remove it */
                p = mp->b_rptr;
                len = ((p[1] << 8) | p[0]) & 0x0fff;
                mp->b_rptr += 2;
        } else {
                len = (((p[1] << 8) | p[0]) & 0x0fff) - ETHERFCSL - 4;
        }

        DPRINTF(2, (CE_CONT, "!%s: %s: rsr:%b len:%d",
            dp->name, __func__, rsr, RSR_BITS, len));

        /* check if error happen */
        if (rsr & RSR_ERRORS) {
                DPRINTF(0, (CE_CONT, "!%s: rsr:%b", dp->name, rsr, RSR_BITS));
                if (rsr & (RSR_CRC | RSR_DRIBBLE)) {
                        dp->stats.frame++;
                }
                if (rsr & RSR_LONG) {
                        dp->stats.frame_too_long++;
                }
                if (rsr & RSR_RUNT) {
                        dp->stats.runt++;
                }

                dp->stats.errrcv++;
                return (NULL);
        }
#ifndef CONFIG_VLAN
        /* check packet size */
        if (len > ETHERMAX) {
                /* too long */
                dp->stats.frame_too_long++;
                dp->stats.errrcv++;
                return (NULL);
        } else if (len < ETHERMIN) {
                dp->stats.runt++;
                dp->stats.errrcv++;
                return (NULL);
        }
#endif
        /* remove tailing crc and rx status fields */
        mp->b_wptr = mp->b_rptr + len;
        ASSERT(mp->b_next == NULL);
        return (mp);
}

/*
 * Device depend interrupt handler
 */
static void
upf_interrupt(struct usbgem_dev *dp, mblk_t *mp)
{
        uint8_t *bp;
        struct upf_dev  *lp = dp->private;

        bp = mp->b_rptr;

        DPRINTF(2, (CE_CONT,
            "!%s: %s: size:%d, %02x %02x %02x %02x %02x %02x %02x %02x",
            dp->name, __func__, mp->b_wptr - mp->b_rptr,
            bp[0], bp[1], bp[2], bp[3], bp[4], bp[5], bp[6], bp[7]));

        if ((lp->last_link_state ^ bp[5]) & 1) {
                DPRINTF(1, (CE_CONT, "!%s:%s link status changed:",
                    dp->name, __func__));
                usbgem_mii_update_link(dp);
        }

        lp->last_link_state = bp[5] & 1;
}

/*
 * MII Interfaces
 */
static uint16_t
upf_mii_read(struct usbgem_dev *dp, uint_t index, int *errp)
{
        uint8_t         phyctrl;
        uint16_t        val;
        int             i;

        DPRINTF(4, (CE_CONT, "!%s: %s: called, ix:%d",
            dp->name, __func__, index));
        ASSERT(index >= 0 && index < 32);

        *errp = USB_SUCCESS;

        /* set PHYADDR */
        OUTB(dp, PHYA, dp->mii_phy_addr, errp, usberr);

        /* Initiate MII read transaction */
        OUTB(dp, PHYAC, index | PHYAC_RDPHY, errp, usberr);

        for (i = 0; i < 100; i++) {
                INB(dp, PHYAC, &phyctrl, errp, usberr);
                if (phyctrl & PHYAC_DO) {
                        /* done */
                        INW(dp, PHYD, &val, errp, usberr);
                        DPRINTF(4, (CE_CONT, "!%s: %s: return %04x",
                            dp->name, __func__, val));
                        return (val);
                }
                drv_usecwait(10);
        }
        /* timeout */
        cmn_err(CE_WARN, "!%s: %s: timeout detected", dp->name, __func__);
        *errp = USB_FAILURE;
        return (0);

usberr:
        cmn_err(CE_CONT,
            "!%s: %s: usberr(%d) detected", dp->name, __func__, *errp);
        return (0);
}

static void
upf_mii_write(struct usbgem_dev *dp, uint_t index, uint16_t val, int *errp)
{
        int             i;
        uint8_t         phyctrl;

        DPRINTF(4, (CE_CONT, "!%s: %s called index:%d val:0x%04x",
            dp->name, __func__, index, val));
        ASSERT(index >= 0 && index < 32);

        *errp = USB_SUCCESS;

        OUTW(dp, PHYD, val, errp, usberr);
        OUTB(dp, PHYA, dp->mii_phy_addr, errp, usberr);
        OUTB(dp, PHYAC, index | PHYAC_WRPHY, errp, usberr);

        for (i = 0; i < 100; i++) {
                INB(dp, PHYAC, &phyctrl, errp, usberr);
                if (phyctrl & PHYAC_DO) {
                        /* done */
                        return;
                }
                drv_usecwait(10);
        }

        /* time out */
        cmn_err(CE_WARN, "!%s: %s: timeout detected", dp->name, __func__);
        *errp = USB_FAILURE;
        return;

usberr:
        cmn_err(CE_CONT,
            "!%s: %s: usberr(%d) detected", dp->name, __func__, *errp);
}


static int
upf_enable_phy(struct usbgem_dev *dp)
{
        uint8_t val;
        int     err;
        struct upf_dev  *lp = dp->private;

        /*
         * first, try to enable internal phy
         */
        INB(dp, IPHYC, &val, &err, usberr);
        val = (val | IPHYC_EPHY) & ~IPHYC_PHYR;
        OUTB(dp, IPHYC, val, &err, usberr);

        INB(dp, IPHYC, &val, &err, usberr);
        DPRINTF(0, (CE_CONT, "!%s: %s: IPHYC: %b",
            dp->name, __func__, val, IPHYC_BITS));
        if (val) {
                /* reset internal phy */
                OUTB(dp, IPHYC, val | IPHYC_PHYR, &err, usberr);
                OUTB(dp, IPHYC, val, &err, usberr);
                delay(drv_usectohz(10000));

                /* identify the chip generation */
                OUTB(dp, 0x83, 0xa5, &err, usberr);
                INB(dp, 0x83, &val, &err, usberr);
                if (val == 0xa5) {
                        lp->chip_type = CHIP_ADM8513;
                } else {
                        /* adm8511 or adm8515 */
                        lp->chip_type = CHIP_ADM8511;
                }
                dp->ugc.usbgc_mii_hw_link_detection = B_TRUE;
        } else {
                /*
                 * It should be AN986 which doesn't have an internal PHY.
                 * We need to setup gpio ports in AN986, which are
                 * connected to external PHY control pins.
                 */
                lp->chip_type = CHIP_AN986;

                /* reset external phy */
                /* output port#0 L, port#1 L */
                OUTB(dp, GPIO10, GPIO10_0O | GPIO10_0OE, &err, usberr);

                /* output port#0 H, port#1 L */
                OUTB(dp, GPIO10,
                    GPIO10_0O | GPIO10_0OE | GPIO10_1OE, &err, usberr);

                /* hw link detection doesn't work correctly */
                dp->ugc.usbgc_mii_hw_link_detection = B_FALSE;
        }

        return (USB_SUCCESS);

usberr:
        cmn_err(CE_NOTE, "!%s: %s: usberr detected", dp->name, __func__);
        return (USB_FAILURE);
}

static int
upf_mii_probe(struct usbgem_dev *dp)
{
        int     err;
        uint16_t        val;
        struct upf_dev  *lp = dp->private;

        if (!lp->phy_init_done) {
                upf_enable_phy(dp);
                lp->phy_init_done = B_TRUE;
        }

        return (usbgem_mii_probe_default(dp));
}

static int
upf_mii_init(struct usbgem_dev *dp)
{
        uint16_t        val;
        int             err = USB_SUCCESS;
        struct upf_dev  *lp = dp->private;

        if (!lp->phy_init_done) {
                upf_enable_phy(dp);
        }
        lp->phy_init_done = B_FALSE;

        if (lp->chip_type == CHIP_AN986 &&
            (lp->vid == 0x0db7 /* elecom */ ||
            lp->vid == 0x066b /* linksys */ ||
            lp->vid == 0x077b /* linksys */ ||
            lp->vid == 0x2001 /* dlink */)) {
                /* special treatment for Linksys products */
                val = upf_mii_read(dp, 0x1b, &err) | 0x4;
                upf_mii_write(dp, 0x1b, val, &err);
        }
        return (err);
}

/* ======================================================== */
/*
 * OS depend (device driver DKI) routine
 */
/* ======================================================== */
static uint16_t
upf_read_eeprom(struct usbgem_dev *dp, int index, int *errp)
{
        int             i;
        uint8_t         eectrl;
        uint16_t        data;

        *errp = USB_SUCCESS;

        OUTB(dp, EECTRL, 0, errp, usberr);

        OUTB(dp, EEOFFSET, index, errp, usberr);
        OUTB(dp, EECTRL, EECTRL_RD, errp, usberr);

        for (i = 0; i < 100; i++) {
                INB(dp, EECTRL, &eectrl, errp, usberr);
                if (eectrl & EECTRL_DONE) {
                        INW(dp, EEDATA, &data, errp, usberr);
                        return (data);
                }
                drv_usecwait(10);
        }

        /* time out */
        *errp = USB_FAILURE;
        return (0);

usberr:
        cmn_err(CE_CONT,
            "!%s: %s: usberr(%d) detected", dp->name, __func__, *errp);
        return (0);
}

static void
upf_eeprom_dump(struct usbgem_dev *dp, int size)
{
        int     i;
        int     err;

        cmn_err(CE_CONT, "!%s: %s dump:", dp->name, __func__);

        for (i = 0; i < size; i += 4) {
                cmn_err(CE_CONT, "!0x%02x: 0x%04x 0x%04x 0x%04x 0x%04x",
                    i*2,
                    upf_read_eeprom(dp, i + 0, &err),
                    upf_read_eeprom(dp, i + 1, &err),
                    upf_read_eeprom(dp, i + 2, &err),
                    upf_read_eeprom(dp, i + 3, &err));
        }
}

static int
upf_attach_chip(struct usbgem_dev *dp)
{
        int             i;
        int             err;
        uint16_t        val;
        uint8_t         *mac;
        struct upf_dev  *lp = dp->private;

        /*
         * Read mac address from EEPROM
         */
        mac = dp->dev_addr.ether_addr_octet;
        for (i = 0; i < 3; i++) {
                val = upf_read_eeprom(dp, i, &err);
                if (err != USB_SUCCESS) {
                        goto usberr;
                }
                mac[i*2+0] = (uint8_t)val;
                mac[i*2+1] = (uint8_t)(val >> 8);
        }

        DPRINTF(0, (CE_CONT,
            "%s: %s: mac: %02x:%02x:%02x:%02x:%02x:%02x",
            dp->name, __func__,
            mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]));

        dp->misc_flag = 0;
#ifdef CONFIG_VLAN
        dp->misc_flag |= USBGEM_VLAN;
#endif
#if DEBUG_LEVEL > 3
        upf_eeprom_dump(dp, 0x80);
#endif
        return (USB_SUCCESS);

usberr:
        cmn_err(CE_WARN, "!%s: %s: usb error detected", dp->name, __func__);
        return (USB_FAILURE);
}

static int
upfattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int                     i;
        ddi_iblock_cookie_t     c;
        int                     ret;
        int                     unit;
        uint32_t                tcr;
        int                     len;
        const char              *drv_name;
        struct usbgem_dev       *dp;
        void                    *base;
        struct usbgem_conf      *ugcp;
        struct upf_dev          *lp;

        unit = ddi_get_instance(dip);
        drv_name = ddi_driver_name(dip);

        DPRINTF(3, (CE_CONT, "!%s%d: %s: called, cmd:%d",
            drv_name, unit, __func__, cmd));

        if (cmd == DDI_ATTACH) {
                /*
                 * construct usbgem configration
                 */
                ugcp = kmem_zalloc(sizeof (*ugcp), KM_SLEEP);

                /* name */
                (void) sprintf(ugcp->usbgc_name, "%s%d", drv_name, unit);
                ugcp->usbgc_ppa = unit;

                ugcp->usbgc_ifnum = 0;
                ugcp->usbgc_alt = 0;

                ugcp->usbgc_tx_list_max = 16;

                ugcp->usbgc_rx_header_len = 4;
                ugcp->usbgc_rx_list_max = 64;

                /* time out parameters */
                ugcp->usbgc_tx_timeout = USBGEM_TX_TIMEOUT;
                ugcp->usbgc_tx_timeout_interval = USBGEM_TX_TIMEOUT_INTERVAL;

                /* flow control */
                ugcp->usbgc_flow_control = FLOW_CONTROL_NONE;
                ugcp->usbgc_flow_control = FLOW_CONTROL_RX_PAUSE;

                /* MII timeout parameters */
                ugcp->usbgc_mii_link_watch_interval = ONESEC;
                ugcp->usbgc_mii_an_watch_interval = ONESEC/5;
                ugcp->usbgc_mii_reset_timeout = MII_RESET_TIMEOUT; /* 1 sec */
                ugcp->usbgc_mii_an_timeout = MII_AN_TIMEOUT;    /* 5 sec */
                ugcp->usbgc_mii_an_wait = MII_AN_TIMEOUT/2;
                ugcp->usbgc_mii_linkdown_timeout = MII_LINKDOWN_TIMEOUT;
                ugcp->usbgc_mii_an_delay = ONESEC/10;

                ugcp->usbgc_mii_linkdown_action = MII_ACTION_RESET;
                ugcp->usbgc_mii_linkdown_timeout_action = MII_ACTION_RESET;
                ugcp->usbgc_mii_dont_reset = B_FALSE;

                /* I/O methods */

                /* mac operation */
                ugcp->usbgc_attach_chip = &upf_attach_chip;
                ugcp->usbgc_reset_chip = &upf_reset_chip;
                ugcp->usbgc_init_chip = &upf_init_chip;
                ugcp->usbgc_start_chip = &upf_start_chip;
                ugcp->usbgc_stop_chip = &upf_stop_chip;
                ugcp->usbgc_multicast_hash = &upf_mcast_hash;

                ugcp->usbgc_set_rx_filter = &upf_set_rx_filter;
                ugcp->usbgc_set_media = &upf_set_media;
                ugcp->usbgc_get_stats = &upf_get_stats;
                ugcp->usbgc_interrupt = &upf_interrupt;

                /* packet operation */
                ugcp->usbgc_tx_make_packet = &upf_tx_make_packet;
                ugcp->usbgc_rx_make_packet = &upf_rx_make_packet;

                /* mii operations */
                ugcp->usbgc_mii_probe = &upf_mii_probe;
                ugcp->usbgc_mii_init = &upf_mii_init;
                ugcp->usbgc_mii_config = &usbgem_mii_config_default;
                ugcp->usbgc_mii_read = &upf_mii_read;
                ugcp->usbgc_mii_write = &upf_mii_write;

                /* mtu */
                ugcp->usbgc_min_mtu = ETHERMTU;
                ugcp->usbgc_max_mtu = ETHERMTU;
                ugcp->usbgc_default_mtu = ETHERMTU;

                lp = kmem_zalloc(sizeof (struct upf_dev), KM_SLEEP);

                lp->vid = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
                    DDI_PROP_DONTPASS, "usb-vendor-id", -1);
                lp->pid = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
                    DDI_PROP_DONTPASS, "usb-product-id", -1);

                dp = usbgem_do_attach(dip, ugcp, lp, sizeof (struct upf_dev));

                kmem_free(ugcp, sizeof (*ugcp));

                if (dp != NULL) {
                        return (DDI_SUCCESS);
                }

                kmem_free(lp, sizeof (struct upf_dev));
                return (DDI_FAILURE);
        }
        if (cmd == DDI_RESUME) {
                dp = USBGEM_GET_DEV(dip);
                lp = dp->private;
                lp->phy_init_done = B_FALSE;

                return (usbgem_resume(dip));
        }
        return (DDI_FAILURE);
}

static int
upfdetach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        int     ret;

        if (cmd == DDI_DETACH) {
                ret = usbgem_do_detach(dip);
                if (ret != DDI_SUCCESS) {
                        return (DDI_FAILURE);
                }
                return (DDI_SUCCESS);
        }
        if (cmd == DDI_SUSPEND) {
                return (usbgem_suspend(dip));
        }
        return (DDI_FAILURE);
}

/* ======================================================== */
/*
 * OS depend (loadable streams driver) routine
 */
/* ======================================================== */

USBGEM_STREAM_OPS(upf_ops, upfattach, upfdetach);

static struct modldrv modldrv = {
        &mod_driverops, /* Type of module.  This one is a driver */
        ident,
        &upf_ops,       /* driver ops */
};

static struct modlinkage modlinkage = {
        MODREV_1, &modldrv, NULL
};

/* ======================================================== */
/*
 * _init : done
 */
/* ======================================================== */
int
_init(void)
{
        int     status;

        DPRINTF(2, (CE_CONT, "!upf: _init: called"));

        status = usbgem_mod_init(&upf_ops, "upf");
        if (status != DDI_SUCCESS) {
                return (status);
        }
        status = mod_install(&modlinkage);
        if (status != DDI_SUCCESS) {
                usbgem_mod_fini(&upf_ops);
        }
        return (status);
}

/*
 * _fini : done
 */
int
_fini(void)
{
        int     status;

        DPRINTF(2, (CE_CONT, "!upf: _fini: called"));
        status = mod_remove(&modlinkage);
        if (status == DDI_SUCCESS) {
                usbgem_mod_fini(&upf_ops);
        }
        return (status);
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}