/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 *  Copyright (c) 2002-2009 Neterion, Inc.
 *  All right Reserved.
 *
 *  FileName :    xgell.c
 *
 *  Description:  Xge Link Layer data path implementation
 *
 */

#include "xgell.h"

#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <netinet/udp.h>

#define XGELL_MAX_FRAME_SIZE(hldev)     ((hldev)->config.mtu +  \
    sizeof (struct ether_vlan_header))

#define HEADROOM                2       /* for DIX-only packets */

void header_free_func(void *arg) { }
frtn_t header_frtn = {header_free_func, NULL};

/* DMA attributes used for Tx side */
static struct ddi_dma_attr tx_dma_attr = {
        DMA_ATTR_V0,                    /* dma_attr_version */
        0x0ULL,                         /* dma_attr_addr_lo */
        0xFFFFFFFFFFFFFFFFULL,          /* dma_attr_addr_hi */
        0xFFFFFFFFFFFFFFFFULL,          /* dma_attr_count_max */
#if defined(__sparc)
        0x2000,                         /* dma_attr_align */
#else
        0x1000,                         /* dma_attr_align */
#endif
        0xFC00FC,                       /* dma_attr_burstsizes */
        0x1,                            /* dma_attr_minxfer */
        0xFFFFFFFFFFFFFFFFULL,          /* dma_attr_maxxfer */
        0xFFFFFFFFFFFFFFFFULL,          /* dma_attr_seg */
        18,                             /* dma_attr_sgllen */
        (unsigned int)1,                /* dma_attr_granular */
        0                               /* dma_attr_flags */
};

/*
 * DMA attributes used when using ddi_dma_mem_alloc to
 * allocat HAL descriptors and Rx buffers during replenish
 */
static struct ddi_dma_attr hal_dma_attr = {
        DMA_ATTR_V0,                    /* dma_attr_version */
        0x0ULL,                         /* dma_attr_addr_lo */
        0xFFFFFFFFFFFFFFFFULL,          /* dma_attr_addr_hi */
        0xFFFFFFFFFFFFFFFFULL,          /* dma_attr_count_max */
#if defined(__sparc)
        0x2000,                         /* dma_attr_align */
#else
        0x1000,                         /* dma_attr_align */
#endif
        0xFC00FC,                       /* dma_attr_burstsizes */
        0x1,                            /* dma_attr_minxfer */
        0xFFFFFFFFFFFFFFFFULL,          /* dma_attr_maxxfer */
        0xFFFFFFFFFFFFFFFFULL,          /* dma_attr_seg */
        1,                              /* dma_attr_sgllen */
        (unsigned int)1,                /* dma_attr_sgllen */
        DDI_DMA_RELAXED_ORDERING        /* dma_attr_flags */
};

struct ddi_dma_attr *p_hal_dma_attr = &hal_dma_attr;

static int              xgell_m_stat(void *, uint_t, uint64_t *);
static int              xgell_m_start(void *);
static void             xgell_m_stop(void *);
static int              xgell_m_promisc(void *, boolean_t);
static int              xgell_m_multicst(void *, boolean_t, const uint8_t *);
static void             xgell_m_ioctl(void *, queue_t *, mblk_t *);
static boolean_t        xgell_m_getcapab(void *, mac_capab_t, void *);

#define XGELL_M_CALLBACK_FLAGS  (MC_IOCTL | MC_GETCAPAB)

static mac_callbacks_t xgell_m_callbacks = {
        XGELL_M_CALLBACK_FLAGS,
        xgell_m_stat,
        xgell_m_start,
        xgell_m_stop,
        xgell_m_promisc,
        xgell_m_multicst,
        NULL,
        NULL,
        NULL,
        xgell_m_ioctl,
        xgell_m_getcapab
};

/*
 * xge_device_poll
 *
 * Timeout should call me every 1s. xge_callback_event_queued should call me
 * when HAL hope event was rescheduled.
 */
/*ARGSUSED*/
void
xge_device_poll(void *data)
{
        xgelldev_t *lldev = xge_hal_device_private(data);

        mutex_enter(&lldev->genlock);
        if (lldev->is_initialized) {
                xge_hal_device_poll(data);
                lldev->timeout_id = timeout(xge_device_poll, data,
                    XGE_DEV_POLL_TICKS);
        } else if (lldev->in_reset == 1) {
                lldev->timeout_id = timeout(xge_device_poll, data,
                    XGE_DEV_POLL_TICKS);
        } else {
                lldev->timeout_id = 0;
        }
        mutex_exit(&lldev->genlock);
}

/*
 * xge_device_poll_now
 *
 * Will call xge_device_poll() immediately
 */
void
xge_device_poll_now(void *data)
{
        xgelldev_t *lldev = xge_hal_device_private(data);

        mutex_enter(&lldev->genlock);
        if (lldev->is_initialized) {
                xge_hal_device_poll(data);
        }
        mutex_exit(&lldev->genlock);
}

/*
 * xgell_callback_link_up
 *
 * This function called by HAL to notify HW link up state change.
 */
void
xgell_callback_link_up(void *userdata)
{
        xgelldev_t *lldev = (xgelldev_t *)userdata;

        mac_link_update(lldev->mh, LINK_STATE_UP);
}

/*
 * xgell_callback_link_down
 *
 * This function called by HAL to notify HW link down state change.
 */
void
xgell_callback_link_down(void *userdata)
{
        xgelldev_t *lldev = (xgelldev_t *)userdata;

        mac_link_update(lldev->mh, LINK_STATE_DOWN);
}

/*
 * xgell_rx_buffer_replenish_all
 *
 * To replenish all freed dtr(s) with buffers in free pool. It's called by
 * xgell_rx_buffer_recycle() or xgell_rx_1b_callback().
 * Must be called with pool_lock held.
 */
static void
xgell_rx_buffer_replenish_all(xgell_rx_ring_t *ring)
{
        xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool;
        xge_hal_dtr_h dtr;
        xgell_rx_buffer_t *rx_buffer;
        xgell_rxd_priv_t *rxd_priv;

        xge_assert(mutex_owned(&bf_pool->pool_lock));

        while ((bf_pool->free > 0) &&
            (xge_hal_ring_dtr_reserve(ring->channelh, &dtr) == XGE_HAL_OK)) {
                xge_assert(bf_pool->head);

                rx_buffer = bf_pool->head;

                bf_pool->head = rx_buffer->next;
                bf_pool->free--;

                xge_assert(rx_buffer->dma_addr);

                rxd_priv = (xgell_rxd_priv_t *)
                    xge_hal_ring_dtr_private(ring->channelh, dtr);
                xge_hal_ring_dtr_1b_set(dtr, rx_buffer->dma_addr,
                    bf_pool->size);

                rxd_priv->rx_buffer = rx_buffer;
                xge_hal_ring_dtr_post(ring->channelh, dtr);
        }
}

/*
 * xgell_rx_buffer_release
 *
 * The only thing done here is to put the buffer back to the pool.
 * Calling this function need be protected by mutex, bf_pool.pool_lock.
 */
static void
xgell_rx_buffer_release(xgell_rx_buffer_t *rx_buffer)
{
        xgell_rx_ring_t *ring = rx_buffer->ring;
        xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool;

        xge_assert(mutex_owned(&bf_pool->pool_lock));

        /* Put the buffer back to pool */
        rx_buffer->next = bf_pool->head;
        bf_pool->head = rx_buffer;

        bf_pool->free++;
}

/*
 * xgell_rx_buffer_recycle
 *
 * Called by desballoc() to "free" the resource.
 * We will try to replenish all descripters.
 */

/*
 * Previously there were much lock contention between xgell_rx_1b_compl() and
 * xgell_rx_buffer_recycle(), which consumed a lot of CPU resources and had bad
 * effect on rx performance. A separate recycle list is introduced to overcome
 * this. The recycle list is used to record the rx buffer that has been recycled
 * and these buffers will be retuned back to the free list in bulk instead of
 * one-by-one.
 */

static void
xgell_rx_buffer_recycle(char *arg)
{
        xgell_rx_buffer_t *rx_buffer = (xgell_rx_buffer_t *)arg;
        xgell_rx_ring_t *ring = rx_buffer->ring;
        xgelldev_t *lldev = ring->lldev;
        xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool;

        mutex_enter(&bf_pool->recycle_lock);

        rx_buffer->next = bf_pool->recycle_head;
        bf_pool->recycle_head = rx_buffer;
        if (bf_pool->recycle_tail == NULL)
                bf_pool->recycle_tail = rx_buffer;
        bf_pool->recycle++;

        /*
         * Before finding a good way to set this hiwat, just always call to
         * replenish_all. *TODO*
         */
        if ((lldev->is_initialized != 0) && (ring->live) &&
            (bf_pool->recycle >= XGELL_RX_BUFFER_RECYCLE_CACHE)) {
                mutex_enter(&bf_pool->pool_lock);
                bf_pool->recycle_tail->next = bf_pool->head;
                bf_pool->head = bf_pool->recycle_head;
                bf_pool->recycle_head = bf_pool->recycle_tail = NULL;
                bf_pool->post -= bf_pool->recycle;
                bf_pool->free += bf_pool->recycle;
                bf_pool->recycle = 0;
                xgell_rx_buffer_replenish_all(ring);
                mutex_exit(&bf_pool->pool_lock);
        }

        mutex_exit(&bf_pool->recycle_lock);
}

/*
 * xgell_rx_buffer_alloc
 *
 * Allocate one rx buffer and return with the pointer to the buffer.
 * Return NULL if failed.
 */
static xgell_rx_buffer_t *
xgell_rx_buffer_alloc(xgell_rx_ring_t *ring)
{
        xgelldev_t *lldev = ring->lldev;
        xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool;
        xge_hal_device_t *hldev;
        void *vaddr;
        ddi_dma_handle_t dma_handle;
        ddi_acc_handle_t dma_acch;
        dma_addr_t dma_addr;
        uint_t ncookies;
        ddi_dma_cookie_t dma_cookie;
        size_t real_size;
        extern ddi_device_acc_attr_t *p_xge_dev_attr;
        xgell_rx_buffer_t *rx_buffer;

        hldev = (xge_hal_device_t *)lldev->devh;

        if (ddi_dma_alloc_handle(hldev->pdev, p_hal_dma_attr, DDI_DMA_SLEEP,
            0, &dma_handle) != DDI_SUCCESS) {
                xge_debug_ll(XGE_ERR, "%s%d: can not allocate DMA handle",
                    XGELL_IFNAME, lldev->instance);
                goto handle_failed;
        }

        /* reserve some space at the end of the buffer for recycling */
        if (ddi_dma_mem_alloc(dma_handle, HEADROOM + bf_pool->size +
            sizeof (xgell_rx_buffer_t), p_xge_dev_attr, DDI_DMA_STREAMING,
            DDI_DMA_SLEEP, 0, (caddr_t *)&vaddr, &real_size, &dma_acch) !=
            DDI_SUCCESS) {
                xge_debug_ll(XGE_ERR, "%s%d: can not allocate DMA-able memory",
                    XGELL_IFNAME, lldev->instance);
                goto mem_failed;
        }

        if (HEADROOM + bf_pool->size + sizeof (xgell_rx_buffer_t) >
            real_size) {
                xge_debug_ll(XGE_ERR, "%s%d: can not allocate DMA-able memory",
                    XGELL_IFNAME, lldev->instance);
                goto bind_failed;
        }

        if (ddi_dma_addr_bind_handle(dma_handle, NULL, (char *)vaddr + HEADROOM,
            bf_pool->size, DDI_DMA_READ | DDI_DMA_STREAMING,
            DDI_DMA_SLEEP, 0, &dma_cookie, &ncookies) != DDI_SUCCESS) {
                xge_debug_ll(XGE_ERR, "%s%d: out of mapping for mblk",
                    XGELL_IFNAME, lldev->instance);
                goto bind_failed;
        }

        if (ncookies != 1 || dma_cookie.dmac_size < bf_pool->size) {
                xge_debug_ll(XGE_ERR, "%s%d: can not handle partial DMA",
                    XGELL_IFNAME, lldev->instance);
                goto check_failed;
        }

        dma_addr = dma_cookie.dmac_laddress;

        rx_buffer = (xgell_rx_buffer_t *)((char *)vaddr + real_size -
            sizeof (xgell_rx_buffer_t));
        rx_buffer->next = NULL;
        rx_buffer->vaddr = vaddr;
        rx_buffer->dma_addr = dma_addr;
        rx_buffer->dma_handle = dma_handle;
        rx_buffer->dma_acch = dma_acch;
        rx_buffer->ring = ring;
        rx_buffer->frtn.free_func = xgell_rx_buffer_recycle;
        rx_buffer->frtn.free_arg = (void *)rx_buffer;

        return (rx_buffer);

check_failed:
        (void) ddi_dma_unbind_handle(dma_handle);
bind_failed:
        XGE_OS_MEMORY_CHECK_FREE(vaddr, 0);
        ddi_dma_mem_free(&dma_acch);
mem_failed:
        ddi_dma_free_handle(&dma_handle);
handle_failed:

        return (NULL);
}

/*
 * xgell_rx_destroy_buffer_pool
 *
 * Destroy buffer pool. If there is still any buffer hold by upper layer,
 * recorded by bf_pool.post, return DDI_FAILURE to reject to be unloaded.
 */
static boolean_t
xgell_rx_destroy_buffer_pool(xgell_rx_ring_t *ring)
{
        xgelldev_t *lldev = ring->lldev;
        xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool;
        xgell_rx_buffer_t *rx_buffer;
        ddi_dma_handle_t  dma_handle;
        ddi_acc_handle_t  dma_acch;
        int i;

        /*
         * If the pool has been destroied, just return B_TRUE
         */
        if (!bf_pool->live)
                return (B_TRUE);

        mutex_enter(&bf_pool->recycle_lock);
        if (bf_pool->recycle > 0) {
                mutex_enter(&bf_pool->pool_lock);
                bf_pool->recycle_tail->next = bf_pool->head;
                bf_pool->head = bf_pool->recycle_head;
                bf_pool->recycle_tail = bf_pool->recycle_head = NULL;
                bf_pool->post -= bf_pool->recycle;
                bf_pool->free += bf_pool->recycle;
                bf_pool->recycle = 0;
                mutex_exit(&bf_pool->pool_lock);
        }
        mutex_exit(&bf_pool->recycle_lock);

        /*
         * If there is any posted buffer, the driver should reject to be
         * detached. Need notice upper layer to release them.
         */
        if (bf_pool->post != 0) {
                xge_debug_ll(XGE_ERR,
                    "%s%d has some buffers not be recycled, try later!",
                    XGELL_IFNAME, lldev->instance);
                return (B_FALSE);
        }

        /*
         * Release buffers one by one.
         */
        for (i = bf_pool->total; i > 0; i--) {
                rx_buffer = bf_pool->head;
                xge_assert(rx_buffer != NULL);

                bf_pool->head = rx_buffer->next;

                dma_handle = rx_buffer->dma_handle;
                dma_acch = rx_buffer->dma_acch;

                if (ddi_dma_unbind_handle(dma_handle) != DDI_SUCCESS) {
                        xge_debug_ll(XGE_ERR, "failed to unbind DMA handle!");
                        bf_pool->head = rx_buffer;
                        return (B_FALSE);
                }
                ddi_dma_mem_free(&dma_acch);
                ddi_dma_free_handle(&dma_handle);

                bf_pool->total--;
                bf_pool->free--;
        }

        xge_assert(!mutex_owned(&bf_pool->pool_lock));

        mutex_destroy(&bf_pool->recycle_lock);
        mutex_destroy(&bf_pool->pool_lock);
        bf_pool->live = B_FALSE;

        return (B_TRUE);
}

/*
 * xgell_rx_create_buffer_pool
 *
 * Initialize RX buffer pool for all RX rings. Refer to rx_buffer_pool_t.
 */
static boolean_t
xgell_rx_create_buffer_pool(xgell_rx_ring_t *ring)
{
        xgelldev_t *lldev = ring->lldev;
        xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool;
        xge_hal_device_t *hldev;
        xgell_rx_buffer_t *rx_buffer;
        int i;

        if (bf_pool->live)
                return (B_TRUE);

        hldev = (xge_hal_device_t *)lldev->devh;

        bf_pool->total = 0;
        bf_pool->size = XGELL_MAX_FRAME_SIZE(hldev);
        bf_pool->head = NULL;
        bf_pool->free = 0;
        bf_pool->post = 0;
        bf_pool->post_hiwat = lldev->config.rx_buffer_post_hiwat;
        bf_pool->recycle = 0;
        bf_pool->recycle_head = NULL;
        bf_pool->recycle_tail = NULL;
        bf_pool->live = B_TRUE;

        mutex_init(&bf_pool->pool_lock, NULL, MUTEX_DRIVER,
            DDI_INTR_PRI(hldev->irqh));
        mutex_init(&bf_pool->recycle_lock, NULL, MUTEX_DRIVER,
            DDI_INTR_PRI(hldev->irqh));

        /*
         * Allocate buffers one by one. If failed, destroy whole pool by
         * call to xgell_rx_destroy_buffer_pool().
         */

        for (i = 0; i < lldev->config.rx_buffer_total; i++) {
                if ((rx_buffer = xgell_rx_buffer_alloc(ring)) == NULL) {
                        (void) xgell_rx_destroy_buffer_pool(ring);
                        return (B_FALSE);
                }

                rx_buffer->next = bf_pool->head;
                bf_pool->head = rx_buffer;

                bf_pool->total++;
                bf_pool->free++;
        }

        return (B_TRUE);
}

/*
 * xgell_rx_dtr_replenish
 *
 * Replenish descriptor with rx_buffer in RX buffer pool.
 * The dtr should be post right away.
 */
xge_hal_status_e
xgell_rx_dtr_replenish(xge_hal_channel_h channelh, xge_hal_dtr_h dtr, int index,
    void *userdata, xge_hal_channel_reopen_e reopen)
{
        xgell_rx_ring_t *ring = userdata;
        xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool;
        xgell_rx_buffer_t *rx_buffer;
        xgell_rxd_priv_t *rxd_priv;

        mutex_enter(&bf_pool->pool_lock);
        if (bf_pool->head == NULL) {
                xge_debug_ll(XGE_ERR, "no more available rx DMA buffer!");
                return (XGE_HAL_FAIL);
        }
        rx_buffer = bf_pool->head;
        xge_assert(rx_buffer);
        xge_assert(rx_buffer->dma_addr);

        bf_pool->head = rx_buffer->next;
        bf_pool->free--;
        mutex_exit(&bf_pool->pool_lock);

        rxd_priv = (xgell_rxd_priv_t *)xge_hal_ring_dtr_private(channelh, dtr);
        xge_hal_ring_dtr_1b_set(dtr, rx_buffer->dma_addr, bf_pool->size);

        rxd_priv->rx_buffer = rx_buffer;

        return (XGE_HAL_OK);
}

/*
 * xgell_get_ip_offset
 *
 * Calculate the offset to IP header.
 */
static inline int
xgell_get_ip_offset(xge_hal_dtr_info_t *ext_info)
{
        int ip_off;

        /* get IP-header offset */
        switch (ext_info->frame) {
        case XGE_HAL_FRAME_TYPE_DIX:
                ip_off = XGE_HAL_HEADER_ETHERNET_II_802_3_SIZE;
                break;
        case XGE_HAL_FRAME_TYPE_IPX:
                ip_off = (XGE_HAL_HEADER_ETHERNET_II_802_3_SIZE +
                    XGE_HAL_HEADER_802_2_SIZE +
                    XGE_HAL_HEADER_SNAP_SIZE);
                break;
        case XGE_HAL_FRAME_TYPE_LLC:
                ip_off = (XGE_HAL_HEADER_ETHERNET_II_802_3_SIZE +
                    XGE_HAL_HEADER_802_2_SIZE);
                break;
        case XGE_HAL_FRAME_TYPE_SNAP:
                ip_off = (XGE_HAL_HEADER_ETHERNET_II_802_3_SIZE +
                    XGE_HAL_HEADER_SNAP_SIZE);
                break;
        default:
                ip_off = 0;
                break;
        }

        if ((ext_info->proto & XGE_HAL_FRAME_PROTO_IPV4 ||
            ext_info->proto & XGE_HAL_FRAME_PROTO_IPV6) &&
            (ext_info->proto & XGE_HAL_FRAME_PROTO_VLAN_TAGGED)) {
                ip_off += XGE_HAL_HEADER_VLAN_SIZE;
        }

        return (ip_off);
}

/*
 * xgell_rx_hcksum_assoc
 *
 * Judge the packet type and then call to hcksum_assoc() to associate
 * h/w checksum information.
 */
static inline void
xgell_rx_hcksum_assoc(mblk_t *mp, char *vaddr, int pkt_length,
    xge_hal_dtr_info_t *ext_info)
{
        int cksum_flags = 0;

        if (!(ext_info->proto & XGE_HAL_FRAME_PROTO_IP_FRAGMENTED)) {
                if (ext_info->proto & XGE_HAL_FRAME_PROTO_TCP_OR_UDP) {
                        if (ext_info->l3_cksum == XGE_HAL_L3_CKSUM_OK) {
                                cksum_flags |= HCK_IPV4_HDRCKSUM_OK;
                        }
                        if (ext_info->l4_cksum == XGE_HAL_L4_CKSUM_OK) {
                                cksum_flags |= HCK_FULLCKSUM_OK;
                        }
                        if (cksum_flags != 0) {
                                mac_hcksum_set(mp, 0, 0, 0, 0, cksum_flags);
                        }
                }
        } else if (ext_info->proto &
            (XGE_HAL_FRAME_PROTO_IPV4 | XGE_HAL_FRAME_PROTO_IPV6)) {
                /*
                 * Just pass the partial cksum up to IP.
                 */
                int ip_off = xgell_get_ip_offset(ext_info);
                int start, end = pkt_length - ip_off;

                if (ext_info->proto & XGE_HAL_FRAME_PROTO_IPV4) {
                        struct ip *ip =
                            (struct ip *)(vaddr + ip_off);
                        start = ip->ip_hl * 4;
                } else {
                        start = 40;
                }
                cksum_flags |= HCK_PARTIALCKSUM;
                mac_hcksum_set(mp, start, 0, end,
                    ntohs(ext_info->l4_cksum), cksum_flags);
        }
}

/*
 * xgell_rx_1b_msg_alloc
 *
 * Allocate message header for data buffer, and decide if copy the packet to
 * new data buffer to release big rx_buffer to save memory.
 *
 * If the pkt_length <= XGELL_RX_DMA_LOWAT, call allocb() to allocate
 * new message and copy the payload in.
 */
static mblk_t *
xgell_rx_1b_msg_alloc(xgell_rx_ring_t *ring, xgell_rx_buffer_t *rx_buffer,
    int pkt_length, xge_hal_dtr_info_t *ext_info, boolean_t *copyit)
{
        xgelldev_t *lldev = ring->lldev;
        mblk_t *mp;
        char *vaddr;

        vaddr = (char *)rx_buffer->vaddr + HEADROOM;
        /*
         * Copy packet into new allocated message buffer, if pkt_length
         * is less than XGELL_RX_DMA_LOWAT
         */
        if (*copyit || pkt_length <= lldev->config.rx_dma_lowat) {
                if ((mp = allocb(pkt_length + HEADROOM, 0)) == NULL) {
                        return (NULL);
                }
                mp->b_rptr += HEADROOM;
                bcopy(vaddr, mp->b_rptr, pkt_length);
                mp->b_wptr = mp->b_rptr + pkt_length;
                *copyit = B_TRUE;
                return (mp);
        }

        /*
         * Just allocate mblk for current data buffer
         */
        if ((mp = (mblk_t *)desballoc((unsigned char *)vaddr, pkt_length, 0,
            &rx_buffer->frtn)) == NULL) {
                /* Drop it */
                return (NULL);
        }
        /*
         * Adjust the b_rptr/b_wptr in the mblk_t structure.
         */
        mp->b_wptr += pkt_length;

        return (mp);
}

/*
 * xgell_rx_1b_callback
 *
 * If the interrupt is because of a received frame or if the receive ring
 * contains fresh as yet un-processed frames, this function is called.
 */
static xge_hal_status_e
xgell_rx_1b_callback(xge_hal_channel_h channelh, xge_hal_dtr_h dtr, u8 t_code,
    void *userdata)
{
        xgell_rx_ring_t *ring = (xgell_rx_ring_t *)userdata;
        xgelldev_t *lldev = ring->lldev;
        xgell_rx_buffer_t *rx_buffer;
        mblk_t *mp_head = NULL;
        mblk_t *mp_end  = NULL;
        int pkt_burst = 0;

        xge_debug_ll(XGE_TRACE, "xgell_rx_1b_callback on ring %d", ring->index);

        mutex_enter(&ring->bf_pool.pool_lock);
        do {
                int pkt_length;
                dma_addr_t dma_data;
                mblk_t *mp;
                boolean_t copyit = B_FALSE;

                xgell_rxd_priv_t *rxd_priv = ((xgell_rxd_priv_t *)
                    xge_hal_ring_dtr_private(channelh, dtr));
                xge_hal_dtr_info_t ext_info;

                rx_buffer = rxd_priv->rx_buffer;

                xge_hal_ring_dtr_1b_get(channelh, dtr, &dma_data, &pkt_length);
                xge_hal_ring_dtr_info_get(channelh, dtr, &ext_info);

                xge_assert(dma_data == rx_buffer->dma_addr);

                if (t_code != 0) {
                        xge_debug_ll(XGE_ERR, "%s%d: rx: dtr 0x%"PRIx64
                            " completed due to error t_code %01x", XGELL_IFNAME,
                            lldev->instance, (uint64_t)(uintptr_t)dtr, t_code);

                        (void) xge_hal_device_handle_tcode(channelh, dtr,
                            t_code);
                        xge_hal_ring_dtr_free(channelh, dtr); /* drop it */
                        xgell_rx_buffer_release(rx_buffer);
                        continue;
                }

                /*
                 * Sync the DMA memory
                 */
                if (ddi_dma_sync(rx_buffer->dma_handle, 0, pkt_length,
                    DDI_DMA_SYNC_FORKERNEL) != DDI_SUCCESS) {
                        xge_debug_ll(XGE_ERR, "%s%d: rx: can not do DMA sync",
                            XGELL_IFNAME, lldev->instance);
                        xge_hal_ring_dtr_free(channelh, dtr); /* drop it */
                        xgell_rx_buffer_release(rx_buffer);
                        continue;
                }

                /*
                 * Allocate message for the packet.
                 */
                if (ring->bf_pool.post > ring->bf_pool.post_hiwat) {
                        copyit = B_TRUE;
                } else {
                        copyit = B_FALSE;
                }

                mp = xgell_rx_1b_msg_alloc(ring, rx_buffer, pkt_length,
                    &ext_info, &copyit);

                xge_hal_ring_dtr_free(channelh, dtr);

                /*
                 * Release the buffer and recycle it later
                 */
                if ((mp == NULL) || copyit) {
                        xgell_rx_buffer_release(rx_buffer);
                } else {
                        /*
                         * Count it since the buffer should be loaned up.
                         */
                        ring->bf_pool.post++;
                }
                if (mp == NULL) {
                        xge_debug_ll(XGE_ERR,
                            "%s%d: rx: can not allocate mp mblk",
                            XGELL_IFNAME, lldev->instance);
                        continue;
                }

                /*
                 * Associate cksum_flags per packet type and h/w
                 * cksum flags.
                 */
                xgell_rx_hcksum_assoc(mp, (char *)rx_buffer->vaddr + HEADROOM,
                    pkt_length, &ext_info);

                ring->rx_pkts++;
                ring->rx_bytes += pkt_length;

                if (mp_head == NULL) {
                        mp_head = mp;
                        mp_end = mp;
                } else {
                        mp_end->b_next = mp;
                        mp_end = mp;
                }

                /*
                 * Inlined implemented polling function.
                 */
                if ((ring->poll_mp == NULL) && (ring->poll_bytes > 0)) {
                        ring->poll_mp = mp_head;
                }
                if (ring->poll_mp != NULL) {
                        if ((ring->poll_bytes -= pkt_length) <= 0) {
                                /* have polled enough packets. */
                                break;
                        } else {
                                /* continue polling packets. */
                                continue;
                        }
                }

                /*
                 * We're not in polling mode, so try to chain more messages
                 * or send the chain up according to pkt_burst.
                 */
                if (++pkt_burst < lldev->config.rx_pkt_burst)
                        continue;

                if (ring->bf_pool.post > ring->bf_pool.post_hiwat) {
                        /* Replenish rx buffers */
                        xgell_rx_buffer_replenish_all(ring);
                }
                mutex_exit(&ring->bf_pool.pool_lock);
                if (mp_head != NULL) {
                        mac_rx_ring(lldev->mh, ring->ring_handle, mp_head,
                            ring->ring_gen_num);
                }
                mp_head = mp_end  = NULL;
                pkt_burst = 0;
                mutex_enter(&ring->bf_pool.pool_lock);

        } while (xge_hal_ring_dtr_next_completed(channelh, &dtr, &t_code) ==
            XGE_HAL_OK);

        /*
         * Always call replenish_all to recycle rx_buffers.
         */
        xgell_rx_buffer_replenish_all(ring);
        mutex_exit(&ring->bf_pool.pool_lock);

        /*
         * If we're not in polling cycle, call mac_rx(), otherwise
         * just return while leaving packets chained to ring->poll_mp.
         */
        if ((ring->poll_mp == NULL) && (mp_head != NULL)) {
                mac_rx_ring(lldev->mh, ring->ring_handle, mp_head,
                    ring->ring_gen_num);
        }

        return (XGE_HAL_OK);
}

mblk_t *
xgell_rx_poll(void *arg, int bytes_to_pickup)
{
        xgell_rx_ring_t *ring = (xgell_rx_ring_t *)arg;
        int got_rx = 0;
        mblk_t *mp;

        xge_debug_ll(XGE_TRACE, "xgell_rx_poll on ring %d", ring->index);

        ring->poll_mp = NULL;
        ring->poll_bytes = bytes_to_pickup;
        (void) xge_hal_device_poll_rx_channel(ring->channelh, &got_rx);

        mp = ring->poll_mp;
        ring->poll_bytes = -1;
        ring->polled_bytes += got_rx;
        ring->poll_mp = NULL;

        return (mp);
}

/*
 * xgell_xmit_compl
 *
 * If an interrupt was raised to indicate DMA complete of the Tx packet,
 * this function is called. It identifies the last TxD whose buffer was
 * freed and frees all skbs whose data have already DMA'ed into the NICs
 * internal memory.
 */
static xge_hal_status_e
xgell_xmit_compl(xge_hal_channel_h channelh, xge_hal_dtr_h dtr, u8 t_code,
    void *userdata)
{
        xgell_tx_ring_t *ring = userdata;
        xgelldev_t *lldev = ring->lldev;

        do {
                xgell_txd_priv_t *txd_priv = ((xgell_txd_priv_t *)
                    xge_hal_fifo_dtr_private(dtr));
                int i;

                if (t_code) {
                        xge_debug_ll(XGE_TRACE, "%s%d: tx: dtr 0x%"PRIx64
                            " completed due to error t_code %01x", XGELL_IFNAME,
                            lldev->instance, (uint64_t)(uintptr_t)dtr, t_code);

                        (void) xge_hal_device_handle_tcode(channelh, dtr,
                            t_code);
                }

                for (i = 0; i < txd_priv->handle_cnt; i++) {
                        if (txd_priv->dma_handles[i] != NULL) {
                                xge_assert(txd_priv->dma_handles[i]);
                                (void) ddi_dma_unbind_handle(
                                    txd_priv->dma_handles[i]);
                                ddi_dma_free_handle(&txd_priv->dma_handles[i]);
                                txd_priv->dma_handles[i] = 0;
                        }
                }
                txd_priv->handle_cnt = 0;

                xge_hal_fifo_dtr_free(channelh, dtr);

                if (txd_priv->mblk != NULL) {
                        freemsg(txd_priv->mblk);
                        txd_priv->mblk = NULL;
                }

        } while (xge_hal_fifo_dtr_next_completed(channelh, &dtr, &t_code) ==
            XGE_HAL_OK);

        if (ring->need_resched)
                mac_tx_ring_update(lldev->mh, ring->ring_handle);

        return (XGE_HAL_OK);
}

mblk_t *
xgell_ring_tx(void *arg, mblk_t *mp)
{
        xgell_tx_ring_t *ring = (xgell_tx_ring_t *)arg;
        mblk_t *bp;
        xgelldev_t *lldev = ring->lldev;
        xge_hal_device_t *hldev = lldev->devh;
        xge_hal_status_e status;
        xge_hal_dtr_h dtr;
        xgell_txd_priv_t *txd_priv;
        uint32_t hckflags;
        uint32_t lsoflags;
        uint32_t mss;
        int handle_cnt, frag_cnt, ret, i, copied;
        boolean_t used_copy;
        uint64_t sent_bytes;

        handle_cnt = frag_cnt = 0;
        sent_bytes = 0;

        if (!lldev->is_initialized || lldev->in_reset)
                return (mp);

        /*
         * If the free Tx dtrs count reaches the lower threshold,
         * inform the gld to stop sending more packets till the free
         * dtrs count exceeds higher threshold. Driver informs the
         * gld through gld_sched call, when the free dtrs count exceeds
         * the higher threshold.
         */
        if (xge_hal_channel_dtr_count(ring->channelh)
            <= XGELL_TX_LEVEL_LOW) {
                xge_debug_ll(XGE_TRACE, "%s%d: queue %d: err on xmit,"
                    "free descriptors count at low threshold %d",
                    XGELL_IFNAME, lldev->instance,
                    ((xge_hal_channel_t *)ring->channelh)->post_qid,
                    XGELL_TX_LEVEL_LOW);
                goto _exit;
        }

        status = xge_hal_fifo_dtr_reserve(ring->channelh, &dtr);
        if (status != XGE_HAL_OK) {
                switch (status) {
                case XGE_HAL_INF_CHANNEL_IS_NOT_READY:
                        xge_debug_ll(XGE_ERR,
                            "%s%d: channel %d is not ready.", XGELL_IFNAME,
                            lldev->instance,
                            ((xge_hal_channel_t *)
                            ring->channelh)->post_qid);
                        goto _exit;
                case XGE_HAL_INF_OUT_OF_DESCRIPTORS:
                        xge_debug_ll(XGE_TRACE, "%s%d: queue %d: error in xmit,"
                            " out of descriptors.", XGELL_IFNAME,
                            lldev->instance,
                            ((xge_hal_channel_t *)
                            ring->channelh)->post_qid);
                        goto _exit;
                default:
                        return (mp);
                }
        }

        txd_priv = xge_hal_fifo_dtr_private(dtr);
        txd_priv->mblk = mp;

        /*
         * VLAN tag should be passed down along with MAC header, so h/w needn't
         * do insertion.
         *
         * For NIC driver that has to strip and re-insert VLAN tag, the example
         * is the other implementation for xge. The driver can simple bcopy()
         * ether_vlan_header to overwrite VLAN tag and let h/w insert the tag
         * automatically, since it's impossible that GLD sends down mp(s) with
         * splited ether_vlan_header.
         *
         * struct ether_vlan_header *evhp;
         * uint16_t tci;
         *
         * evhp = (struct ether_vlan_header *)mp->b_rptr;
         * if (evhp->ether_tpid == htons(VLAN_TPID)) {
         *      tci = ntohs(evhp->ether_tci);
         *      (void) bcopy(mp->b_rptr, mp->b_rptr + VLAN_TAGSZ,
         *          2 * ETHERADDRL);
         *      mp->b_rptr += VLAN_TAGSZ;
         *
         *      xge_hal_fifo_dtr_vlan_set(dtr, tci);
         * }
         */

        copied = 0;
        used_copy = B_FALSE;
        for (bp = mp; bp != NULL; bp = bp->b_cont) {
                int mblen;
                uint_t ncookies;
                ddi_dma_cookie_t dma_cookie;
                ddi_dma_handle_t dma_handle;

                /* skip zero-length message blocks */
                mblen = MBLKL(bp);
                if (mblen == 0) {
                        continue;
                }

                sent_bytes += mblen;

                /*
                 * Check the message length to decide to DMA or bcopy() data
                 * to tx descriptor(s).
                 */
                if (mblen < lldev->config.tx_dma_lowat &&
                    (copied + mblen) < lldev->tx_copied_max) {
                        xge_hal_status_e rc;
                        rc = xge_hal_fifo_dtr_buffer_append(ring->channelh,
                            dtr, bp->b_rptr, mblen);
                        if (rc == XGE_HAL_OK) {
                                used_copy = B_TRUE;
                                copied += mblen;
                                continue;
                        } else if (used_copy) {
                                xge_hal_fifo_dtr_buffer_finalize(
                                    ring->channelh, dtr, frag_cnt++);
                                used_copy = B_FALSE;
                        }
                } else if (used_copy) {
                        xge_hal_fifo_dtr_buffer_finalize(ring->channelh,
                            dtr, frag_cnt++);
                        used_copy = B_FALSE;
                }

                ret = ddi_dma_alloc_handle(lldev->dev_info, &tx_dma_attr,
                    DDI_DMA_DONTWAIT, 0, &dma_handle);
                if (ret != DDI_SUCCESS) {
                        xge_debug_ll(XGE_ERR,
                            "%s%d: can not allocate dma handle", XGELL_IFNAME,
                            lldev->instance);
                        goto _exit_cleanup;
                }

                ret = ddi_dma_addr_bind_handle(dma_handle, NULL,
                    (caddr_t)bp->b_rptr, mblen,
                    DDI_DMA_WRITE | DDI_DMA_STREAMING, DDI_DMA_DONTWAIT, 0,
                    &dma_cookie, &ncookies);

                switch (ret) {
                case DDI_DMA_MAPPED:
                        /* everything's fine */
                        break;

                case DDI_DMA_NORESOURCES:
                        xge_debug_ll(XGE_ERR,
                            "%s%d: can not bind dma address",
                            XGELL_IFNAME, lldev->instance);
                        ddi_dma_free_handle(&dma_handle);
                        goto _exit_cleanup;

                case DDI_DMA_NOMAPPING:
                case DDI_DMA_INUSE:
                case DDI_DMA_TOOBIG:
                default:
                        /* drop packet, don't retry */
                        xge_debug_ll(XGE_ERR,
                            "%s%d: can not map message buffer",
                            XGELL_IFNAME, lldev->instance);
                        ddi_dma_free_handle(&dma_handle);
                        goto _exit_cleanup;
                }

                if (ncookies + frag_cnt > hldev->config.fifo.max_frags) {
                        xge_debug_ll(XGE_ERR, "%s%d: too many fragments, "
                            "requested c:%d+f:%d", XGELL_IFNAME,
                            lldev->instance, ncookies, frag_cnt);
                        (void) ddi_dma_unbind_handle(dma_handle);
                        ddi_dma_free_handle(&dma_handle);
                        goto _exit_cleanup;
                }

                /* setup the descriptors for this data buffer */
                while (ncookies) {
                        xge_hal_fifo_dtr_buffer_set(ring->channelh, dtr,
                            frag_cnt++, dma_cookie.dmac_laddress,
                            dma_cookie.dmac_size);
                        if (--ncookies) {
                                ddi_dma_nextcookie(dma_handle, &dma_cookie);
                        }

                }

                txd_priv->dma_handles[handle_cnt++] = dma_handle;

                if (bp->b_cont &&
                    (frag_cnt + XGE_HAL_DEFAULT_FIFO_FRAGS_THRESHOLD >=
                    hldev->config.fifo.max_frags)) {
                        mblk_t *nmp;

                        xge_debug_ll(XGE_TRACE,
                            "too many FRAGs [%d], pull up them", frag_cnt);

                        if ((nmp = msgpullup(bp->b_cont, -1)) == NULL) {
                                /* Drop packet, don't retry */
                                xge_debug_ll(XGE_ERR,
                                    "%s%d: can not pullup message buffer",
                                    XGELL_IFNAME, lldev->instance);
                                goto _exit_cleanup;
                        }
                        freemsg(bp->b_cont);
                        bp->b_cont = nmp;
                }
        }

        /* finalize unfinished copies */
        if (used_copy) {
                xge_hal_fifo_dtr_buffer_finalize(ring->channelh, dtr,
                    frag_cnt++);
        }

        txd_priv->handle_cnt = handle_cnt;

        /*
         * If LSO is required, just call xge_hal_fifo_dtr_mss_set(dtr, mss) to
         * do all necessary work.
         */
        mac_lso_get(mp, &mss, &lsoflags);

        if (lsoflags & HW_LSO) {
                xge_assert((mss != 0) && (mss <= XGE_HAL_DEFAULT_MTU));
                xge_hal_fifo_dtr_mss_set(dtr, mss);
        }

        mac_hcksum_get(mp, NULL, NULL, NULL, NULL, &hckflags);
        if (hckflags & HCK_IPV4_HDRCKSUM) {
                xge_hal_fifo_dtr_cksum_set_bits(dtr,
                    XGE_HAL_TXD_TX_CKO_IPV4_EN);
        }
        if (hckflags & HCK_FULLCKSUM) {
                xge_hal_fifo_dtr_cksum_set_bits(dtr, XGE_HAL_TXD_TX_CKO_TCP_EN |
                    XGE_HAL_TXD_TX_CKO_UDP_EN);
        }

        xge_hal_fifo_dtr_post(ring->channelh, dtr);

        /* Update per-ring tx statistics */
        atomic_inc_64(&ring->tx_pkts);
        atomic_add_64(&ring->tx_bytes, sent_bytes);

        return (NULL);

_exit_cleanup:
        /*
         * Could not successfully transmit but have changed the message,
         * so just free it and return NULL
         */
        for (i = 0; i < handle_cnt; i++) {
                (void) ddi_dma_unbind_handle(txd_priv->dma_handles[i]);
                ddi_dma_free_handle(&txd_priv->dma_handles[i]);
                txd_priv->dma_handles[i] = 0;
        }

        xge_hal_fifo_dtr_free(ring->channelh, dtr);

        freemsg(mp);
        return (NULL);

_exit:
        ring->need_resched = B_TRUE;
        return (mp);
}

/*
 * xgell_ring_macaddr_init
 */
static void
xgell_rx_ring_maddr_init(xgell_rx_ring_t *ring)
{
        int i;
        xgelldev_t *lldev = ring->lldev;
        xge_hal_device_t *hldev = lldev->devh;
        int slot_start;

        xge_debug_ll(XGE_TRACE, "%s", "xgell_rx_ring_maddr_init");

        ring->mmac.naddr = XGE_RX_MULTI_MAC_ADDRESSES_MAX;
        ring->mmac.naddrfree = ring->mmac.naddr;

        /*
         * For the default rx ring, the first MAC address is the factory one.
         * This will be set by the framework, so need to clear it for now.
         */
        (void) xge_hal_device_macaddr_clear(hldev, 0);

        /*
         * Read the MAC address Configuration Memory from HAL.
         * The first slot will hold a factory MAC address, contents in other
         * slots will be FF:FF:FF:FF:FF:FF.
         */
        slot_start = ring->index * 32;
        for (i = 0; i < ring->mmac.naddr; i++) {
                (void) xge_hal_device_macaddr_get(hldev, slot_start + i,
                    ring->mmac.mac_addr + i);
                ring->mmac.mac_addr_set[i] = B_FALSE;
        }
}

static int xgell_maddr_set(xgelldev_t *, int, uint8_t *);

static int
xgell_addmac(void *arg, const uint8_t *mac_addr)
{
        xgell_rx_ring_t *ring = arg;
        xgelldev_t *lldev = ring->lldev;
        xge_hal_device_t *hldev = lldev->devh;
        int slot;
        int slot_start;

        xge_debug_ll(XGE_TRACE, "%s", "xgell_addmac");

        mutex_enter(&lldev->genlock);

        if (ring->mmac.naddrfree == 0) {
                mutex_exit(&lldev->genlock);
                return (ENOSPC);
        }

        /* First slot is for factory MAC address */
        for (slot = 0; slot < ring->mmac.naddr; slot++) {
                if (ring->mmac.mac_addr_set[slot] == B_FALSE) {
                        break;
                }
        }

        ASSERT(slot < ring->mmac.naddr);

        slot_start = ring->index * 32;

        if (xgell_maddr_set(lldev, slot_start + slot, (uint8_t *)mac_addr) !=
            0) {
                mutex_exit(&lldev->genlock);
                return (EIO);
        }

        /* Simply enable RTS for the whole section. */
        (void) xge_hal_device_rts_section_enable(hldev, slot_start + slot);

        /*
         * Read back the MAC address from HAL to keep the array up to date.
         */
        if (xge_hal_device_macaddr_get(hldev, slot_start + slot,
            ring->mmac.mac_addr + slot) != XGE_HAL_OK) {
                (void) xge_hal_device_macaddr_clear(hldev, slot_start + slot);
                return (EIO);
        }

        ring->mmac.mac_addr_set[slot] = B_TRUE;
        ring->mmac.naddrfree--;

        mutex_exit(&lldev->genlock);

        return (0);
}

static int
xgell_remmac(void *arg, const uint8_t *mac_addr)
{
        xgell_rx_ring_t *ring = arg;
        xgelldev_t *lldev = ring->lldev;
        xge_hal_device_t *hldev = lldev->devh;
        xge_hal_status_e status;
        int slot;
        int slot_start;

        xge_debug_ll(XGE_TRACE, "%s", "xgell_remmac");

        slot = xge_hal_device_macaddr_find(hldev, (uint8_t *)mac_addr);
        if (slot == -1)
                return (EINVAL);

        slot_start = ring->index * 32;

        /*
         * Adjust slot to the offset in the MAC array of this ring (group).
         */
        slot -= slot_start;

        /*
         * Only can remove a pre-set MAC address for this ring (group).
         */
        if (slot < 0 || slot >= ring->mmac.naddr)
                return (EINVAL);


        xge_assert(ring->mmac.mac_addr_set[slot]);

        mutex_enter(&lldev->genlock);
        if (!ring->mmac.mac_addr_set[slot]) {
                mutex_exit(&lldev->genlock);
                /*
                 * The result will be unexpected when reach here. WARNING!
                 */
                xge_debug_ll(XGE_ERR,
                    "%s%d: caller is trying to remove an unset MAC address",
                    XGELL_IFNAME, lldev->instance);
                return (ENXIO);
        }

        status = xge_hal_device_macaddr_clear(hldev, slot_start + slot);
        if (status != XGE_HAL_OK) {
                mutex_exit(&lldev->genlock);
                return (EIO);
        }

        ring->mmac.mac_addr_set[slot] = B_FALSE;
        ring->mmac.naddrfree++;

        /*
         * TODO: Disable MAC RTS if all addresses have been cleared.
         */

        /*
         * Read back the MAC address from HAL to keep the array up to date.
         */
        (void) xge_hal_device_macaddr_get(hldev, slot_start + slot,
            ring->mmac.mac_addr + slot);
        mutex_exit(&lldev->genlock);

        return (0);
}

/*
 * Temporarily calling hal function.
 *
 * With MSI-X implementation, no lock is needed, so that the interrupt
 * handling could be faster.
 */
int
xgell_rx_ring_intr_enable(mac_intr_handle_t ih)
{
        xgell_rx_ring_t *ring = (xgell_rx_ring_t *)ih;

        mutex_enter(&ring->ring_lock);
        xge_hal_device_rx_channel_disable_polling(ring->channelh);
        mutex_exit(&ring->ring_lock);

        return (0);
}

int
xgell_rx_ring_intr_disable(mac_intr_handle_t ih)
{
        xgell_rx_ring_t *ring = (xgell_rx_ring_t *)ih;

        mutex_enter(&ring->ring_lock);
        xge_hal_device_rx_channel_enable_polling(ring->channelh);
        mutex_exit(&ring->ring_lock);

        return (0);
}

static int
xgell_rx_ring_start(mac_ring_driver_t rh, uint64_t mr_gen_num)
{
        xgell_rx_ring_t *rx_ring = (xgell_rx_ring_t *)rh;

        rx_ring->ring_gen_num = mr_gen_num;

        return (0);
}

/*ARGSUSED*/
static void
xgell_rx_ring_stop(mac_ring_driver_t rh)
{
}

/*ARGSUSED*/
static int
xgell_tx_ring_start(mac_ring_driver_t rh, uint64_t useless)
{
        return (0);
}

/*ARGSUSED*/
static void
xgell_tx_ring_stop(mac_ring_driver_t rh)
{
}

/*
 * Callback funtion for MAC layer to register all rings.
 *
 * Xframe hardware doesn't support grouping explicitly, so the driver needs
 * to pretend having resource groups. We may also optionally group all 8 rx
 * rings into a single group for increased scalability on CMT architectures,
 * or group one rx ring per group for maximum virtualization.
 *
 * TX grouping is actually done by framework, so, just register all TX
 * resources without grouping them.
 */
void
xgell_fill_ring(void *arg, mac_ring_type_t rtype, const int rg_index,
    const int index, mac_ring_info_t *infop, mac_ring_handle_t rh)
{
        xgelldev_t *lldev = (xgelldev_t *)arg;
        mac_intr_t *mintr;

        switch (rtype) {
        case MAC_RING_TYPE_RX: {
                xgell_rx_ring_t *rx_ring;

                xge_assert(index < lldev->init_rx_rings);
                xge_assert(rg_index < lldev->init_rx_groups);

                /*
                 * Performance vs. Virtualization
                 */
                if (lldev->init_rx_rings == lldev->init_rx_groups)
                        rx_ring = lldev->rx_ring + rg_index;
                else
                        rx_ring = lldev->rx_ring + index;

                rx_ring->ring_handle = rh;

                infop->mri_driver = (mac_ring_driver_t)rx_ring;
                infop->mri_start = xgell_rx_ring_start;
                infop->mri_stop = xgell_rx_ring_stop;
                infop->mri_poll = xgell_rx_poll;
                infop->mri_stat = xgell_rx_ring_stat;

                mintr = &infop->mri_intr;
                mintr->mi_handle = (mac_intr_handle_t)rx_ring;
                mintr->mi_enable = xgell_rx_ring_intr_enable;
                mintr->mi_disable = xgell_rx_ring_intr_disable;

                break;
        }
        case MAC_RING_TYPE_TX: {
                xgell_tx_ring_t *tx_ring;

                xge_assert(rg_index == -1);

                xge_assert((index >= 0) && (index < lldev->init_tx_rings));

                tx_ring = lldev->tx_ring + index;
                tx_ring->ring_handle = rh;

                infop->mri_driver = (mac_ring_driver_t)tx_ring;
                infop->mri_start = xgell_tx_ring_start;
                infop->mri_stop = xgell_tx_ring_stop;
                infop->mri_tx = xgell_ring_tx;
                infop->mri_stat = xgell_tx_ring_stat;

                break;
        }
        default:
                break;
        }
}

void
xgell_fill_group(void *arg, mac_ring_type_t rtype, const int index,
    mac_group_info_t *infop, mac_group_handle_t gh)
{
        xgelldev_t *lldev = (xgelldev_t *)arg;

        switch (rtype) {
        case MAC_RING_TYPE_RX: {
                xgell_rx_ring_t *rx_ring;

                xge_assert(index < lldev->init_rx_groups);

                rx_ring = lldev->rx_ring + index;

                rx_ring->group_handle = gh;

                infop->mgi_driver = (mac_group_driver_t)rx_ring;
                infop->mgi_start = NULL;
                infop->mgi_stop = NULL;
                infop->mgi_addmac = xgell_addmac;
                infop->mgi_remmac = xgell_remmac;
                infop->mgi_count = lldev->init_rx_rings / lldev->init_rx_groups;

                break;
        }
        case MAC_RING_TYPE_TX:
                xge_assert(0);
                break;
        default:
                break;
        }
}

/*
 * xgell_macaddr_set
 */
static int
xgell_maddr_set(xgelldev_t *lldev, int index, uint8_t *macaddr)
{
        xge_hal_device_t *hldev = lldev->devh;
        xge_hal_status_e status;

        xge_debug_ll(XGE_TRACE, "%s", "xgell_maddr_set");

        xge_debug_ll(XGE_TRACE,
            "setting macaddr: 0x%02x-%02x-%02x-%02x-%02x-%02x",
            macaddr[0], macaddr[1], macaddr[2],
            macaddr[3], macaddr[4], macaddr[5]);

        status = xge_hal_device_macaddr_set(hldev, index, (uchar_t *)macaddr);

        if (status != XGE_HAL_OK) {
                xge_debug_ll(XGE_ERR, "%s%d: can not set mac address",
                    XGELL_IFNAME, lldev->instance);
                return (EIO);
        }

        return (0);
}

/*
 * xgell_rx_dtr_term
 *
 * Function will be called by HAL to terminate all DTRs for
 * Ring(s) type of channels.
 */
static void
xgell_rx_dtr_term(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh,
    xge_hal_dtr_state_e state, void *userdata, xge_hal_channel_reopen_e reopen)
{
        xgell_rxd_priv_t *rxd_priv =
            ((xgell_rxd_priv_t *)xge_hal_ring_dtr_private(channelh, dtrh));
        xgell_rx_buffer_t *rx_buffer = rxd_priv->rx_buffer;

        if (state == XGE_HAL_DTR_STATE_POSTED) {
                xgell_rx_ring_t *ring = rx_buffer->ring;

                mutex_enter(&ring->bf_pool.pool_lock);
                xge_hal_ring_dtr_free(channelh, dtrh);
                xgell_rx_buffer_release(rx_buffer);
                mutex_exit(&ring->bf_pool.pool_lock);
        }
}

/*
 * To open a rx ring.
 */
static boolean_t
xgell_rx_ring_open(xgell_rx_ring_t *rx_ring)
{
        xge_hal_status_e status;
        xge_hal_channel_attr_t attr;
        xgelldev_t *lldev = rx_ring->lldev;
        xge_hal_device_t *hldev = lldev->devh;

        if (rx_ring->live)
                return (B_TRUE);

        /* Create the buffer pool first */
        if (!xgell_rx_create_buffer_pool(rx_ring)) {
                xge_debug_ll(XGE_ERR, "can not create buffer pool for ring: %d",
                    rx_ring->index);
                return (B_FALSE);
        }

        /* Default ring initialization */
        attr.post_qid           = rx_ring->index;
        attr.compl_qid          = 0;
        attr.callback           = xgell_rx_1b_callback;
        attr.per_dtr_space      = sizeof (xgell_rxd_priv_t);
        attr.flags              = 0;
        attr.type               = XGE_HAL_CHANNEL_TYPE_RING;
        attr.dtr_init           = xgell_rx_dtr_replenish;
        attr.dtr_term           = xgell_rx_dtr_term;
        attr.userdata           = rx_ring;

        status = xge_hal_channel_open(lldev->devh, &attr, &rx_ring->channelh,
            XGE_HAL_CHANNEL_OC_NORMAL);
        if (status != XGE_HAL_OK) {
                xge_debug_ll(XGE_ERR, "%s%d: cannot open Rx channel got status "
                    " code %d", XGELL_IFNAME, lldev->instance, status);
                (void) xgell_rx_destroy_buffer_pool(rx_ring);
                return (B_FALSE);
        }

        xgell_rx_ring_maddr_init(rx_ring);

        mutex_init(&rx_ring->ring_lock, NULL, MUTEX_DRIVER,
            DDI_INTR_PRI(hldev->irqh));

        rx_ring->poll_bytes = -1;
        rx_ring->polled_bytes = 0;
        rx_ring->poll_mp = NULL;
        rx_ring->live = B_TRUE;

        xge_debug_ll(XGE_TRACE, "RX ring [%d] is opened successfully",
            rx_ring->index);

        return (B_TRUE);
}

static void
xgell_rx_ring_close(xgell_rx_ring_t *rx_ring)
{
        if (!rx_ring->live)
                return;
        xge_hal_channel_close(rx_ring->channelh, XGE_HAL_CHANNEL_OC_NORMAL);
        rx_ring->channelh = NULL;
        /* This may not clean up all used buffers, driver will handle it */
        if (xgell_rx_destroy_buffer_pool(rx_ring))
                rx_ring->live = B_FALSE;

        mutex_destroy(&rx_ring->ring_lock);
}

/*
 * xgell_rx_open
 * @lldev: the link layer object
 *
 * Initialize and open all RX channels.
 */
static boolean_t
xgell_rx_open(xgelldev_t *lldev)
{
        xgell_rx_ring_t *rx_ring;
        int i;

        if (lldev->live_rx_rings != 0)
                return (B_TRUE);

        lldev->live_rx_rings = 0;

        /*
         * Initialize all rings
         */
        for (i = 0; i < lldev->init_rx_rings; i++) {
                rx_ring = &lldev->rx_ring[i];
                rx_ring->index = i;
                rx_ring->lldev = lldev;
                rx_ring->live = B_FALSE;

                if (!xgell_rx_ring_open(rx_ring))
                        return (B_FALSE);

                lldev->live_rx_rings++;
        }

        return (B_TRUE);
}

static void
xgell_rx_close(xgelldev_t *lldev)
{
        xgell_rx_ring_t *rx_ring;
        int i;

        if (lldev->live_rx_rings == 0)
                return;

        /*
         * Close all rx rings
         */
        for (i = 0; i < lldev->init_rx_rings; i++) {
                rx_ring = &lldev->rx_ring[i];

                if (rx_ring->live) {
                        xgell_rx_ring_close(rx_ring);
                        lldev->live_rx_rings--;
                }
        }

        xge_assert(lldev->live_rx_rings == 0);
}

/*
 * xgell_tx_term
 *
 * Function will be called by HAL to terminate all DTRs for
 * Fifo(s) type of channels.
 */
static void
xgell_tx_term(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh,
    xge_hal_dtr_state_e state, void *userdata, xge_hal_channel_reopen_e reopen)
{
        xgell_txd_priv_t *txd_priv =
            ((xgell_txd_priv_t *)xge_hal_fifo_dtr_private(dtrh));
        mblk_t *mp = txd_priv->mblk;
        int i;

        /*
         * for Tx we must clean up the DTR *only* if it has been
         * posted!
         */
        if (state != XGE_HAL_DTR_STATE_POSTED) {
                return;
        }

        for (i = 0; i < txd_priv->handle_cnt; i++) {
                xge_assert(txd_priv->dma_handles[i]);
                (void) ddi_dma_unbind_handle(txd_priv->dma_handles[i]);
                ddi_dma_free_handle(&txd_priv->dma_handles[i]);
                txd_priv->dma_handles[i] = 0;
        }

        xge_hal_fifo_dtr_free(channelh, dtrh);

        if (mp) {
                txd_priv->mblk = NULL;
                freemsg(mp);
        }
}

static boolean_t
xgell_tx_ring_open(xgell_tx_ring_t *tx_ring)
{
        xge_hal_status_e status;
        xge_hal_channel_attr_t attr;
        xgelldev_t *lldev = tx_ring->lldev;

        if (tx_ring->live)
                return (B_TRUE);

        attr.post_qid           = tx_ring->index;
        attr.compl_qid          = 0;
        attr.callback           = xgell_xmit_compl;
        attr.per_dtr_space      = sizeof (xgell_txd_priv_t);
        attr.flags              = 0;
        attr.type               = XGE_HAL_CHANNEL_TYPE_FIFO;
        attr.dtr_init           = NULL;
        attr.dtr_term           = xgell_tx_term;
        attr.userdata           = tx_ring;

        status = xge_hal_channel_open(lldev->devh, &attr, &tx_ring->channelh,
            XGE_HAL_CHANNEL_OC_NORMAL);
        if (status != XGE_HAL_OK) {
                xge_debug_ll(XGE_ERR, "%s%d: cannot open Tx channel got status "
                    "code %d", XGELL_IFNAME, lldev->instance, status);
                return (B_FALSE);
        }

        tx_ring->live = B_TRUE;

        return (B_TRUE);
}

static void
xgell_tx_ring_close(xgell_tx_ring_t *tx_ring)
{
        if (!tx_ring->live)
                return;
        xge_hal_channel_close(tx_ring->channelh, XGE_HAL_CHANNEL_OC_NORMAL);
        tx_ring->live = B_FALSE;
}

/*
 * xgell_tx_open
 * @lldev: the link layer object
 *
 * Initialize and open all TX channels.
 */
static boolean_t
xgell_tx_open(xgelldev_t *lldev)
{
        xgell_tx_ring_t *tx_ring;
        int i;

        if (lldev->live_tx_rings != 0)
                return (B_TRUE);

        lldev->live_tx_rings = 0;

        /*
         * Enable rings by reserve sequence to match the h/w sequences.
         */
        for (i = 0; i < lldev->init_tx_rings; i++) {
                tx_ring = &lldev->tx_ring[i];
                tx_ring->index = i;
                tx_ring->lldev = lldev;
                tx_ring->live = B_FALSE;

                if (!xgell_tx_ring_open(tx_ring))
                        return (B_FALSE);

                lldev->live_tx_rings++;
        }

        return (B_TRUE);
}

static void
xgell_tx_close(xgelldev_t *lldev)
{
        xgell_tx_ring_t *tx_ring;
        int i;

        if (lldev->live_tx_rings == 0)
                return;

        /*
         * Enable rings by reserve sequence to match the h/w sequences.
         */
        for (i = 0; i < lldev->init_tx_rings; i++) {
                tx_ring = &lldev->tx_ring[i];
                if (tx_ring->live) {
                        xgell_tx_ring_close(tx_ring);
                        lldev->live_tx_rings--;
                }
        }
}

static int
xgell_initiate_start(xgelldev_t *lldev)
{
        xge_hal_status_e status;
        xge_hal_device_t *hldev = lldev->devh;
        int maxpkt = hldev->config.mtu;

        /* check initial mtu before enabling the device */
        status = xge_hal_device_mtu_check(lldev->devh, maxpkt);
        if (status != XGE_HAL_OK) {
                xge_debug_ll(XGE_ERR, "%s%d: MTU size %d is invalid",
                    XGELL_IFNAME, lldev->instance, maxpkt);
                return (EINVAL);
        }

        /* set initial mtu before enabling the device */
        status = xge_hal_device_mtu_set(lldev->devh, maxpkt);
        if (status != XGE_HAL_OK) {
                xge_debug_ll(XGE_ERR, "%s%d: can not set new MTU %d",
                    XGELL_IFNAME, lldev->instance, maxpkt);
                return (EIO);
        }

        /* tune jumbo/normal frame UFC counters */
        hldev->config.ring.queue[XGELL_RX_RING_MAIN].rti.ufc_b =
            (maxpkt > XGE_HAL_DEFAULT_MTU) ?
            XGE_HAL_DEFAULT_RX_UFC_B_J :
            XGE_HAL_DEFAULT_RX_UFC_B_N;

        hldev->config.ring.queue[XGELL_RX_RING_MAIN].rti.ufc_c =
            (maxpkt > XGE_HAL_DEFAULT_MTU) ?
            XGE_HAL_DEFAULT_RX_UFC_C_J :
            XGE_HAL_DEFAULT_RX_UFC_C_N;

        /* now, enable the device */
        status = xge_hal_device_enable(lldev->devh);
        if (status != XGE_HAL_OK) {
                xge_debug_ll(XGE_ERR, "%s%d: can not enable the device",
                    XGELL_IFNAME, lldev->instance);
                return (EIO);
        }

        if (!xgell_rx_open(lldev)) {
                status = xge_hal_device_disable(lldev->devh);
                if (status != XGE_HAL_OK) {
                        u64 adapter_status;
                        (void) xge_hal_device_status(lldev->devh,
                            &adapter_status);
                        xge_debug_ll(XGE_ERR, "%s%d: can not safely disable "
                            "the device. adaper status 0x%"PRIx64
                            " returned status %d",
                            XGELL_IFNAME, lldev->instance,
                            (uint64_t)adapter_status, status);
                }
                xgell_rx_close(lldev);
                xge_os_mdelay(1500);
                return (ENOMEM);
        }

        if (!xgell_tx_open(lldev)) {
                status = xge_hal_device_disable(lldev->devh);
                if (status != XGE_HAL_OK) {
                        u64 adapter_status;
                        (void) xge_hal_device_status(lldev->devh,
                            &adapter_status);
                        xge_debug_ll(XGE_ERR, "%s%d: can not safely disable "
                            "the device. adaper status 0x%"PRIx64
                            " returned status %d",
                            XGELL_IFNAME, lldev->instance,
                            (uint64_t)adapter_status, status);
                }
                xgell_tx_close(lldev);
                xgell_rx_close(lldev);
                xge_os_mdelay(1500);
                return (ENOMEM);
        }

        /* time to enable interrupts */
        (void) xge_enable_intrs(lldev);
        xge_hal_device_intr_enable(lldev->devh);

        lldev->is_initialized = 1;

        return (0);
}

static void
xgell_initiate_stop(xgelldev_t *lldev)
{
        xge_hal_status_e status;

        lldev->is_initialized = 0;

        status = xge_hal_device_disable(lldev->devh);
        if (status != XGE_HAL_OK) {
                u64 adapter_status;
                (void) xge_hal_device_status(lldev->devh, &adapter_status);
                xge_debug_ll(XGE_ERR, "%s%d: can not safely disable "
                    "the device. adaper status 0x%"PRIx64" returned status %d",
                    XGELL_IFNAME, lldev->instance,
                    (uint64_t)adapter_status, status);
        }
        xge_hal_device_intr_disable(lldev->devh);
        /* disable OS ISR's */
        xge_disable_intrs(lldev);

        xge_debug_ll(XGE_TRACE, "%s",
            "waiting for device irq to become quiescent...");
        xge_os_mdelay(1500);

        xge_queue_flush(xge_hal_device_queue(lldev->devh));

        xgell_rx_close(lldev);
        xgell_tx_close(lldev);
}

/*
 * xgell_m_start
 * @arg: pointer to device private strucutre(hldev)
 *
 * This function is called by MAC Layer to enable the XFRAME
 * firmware to generate interrupts and also prepare the
 * driver to call mac_rx for delivering receive packets
 * to MAC Layer.
 */
static int
xgell_m_start(void *arg)
{
        xgelldev_t *lldev = arg;
        xge_hal_device_t *hldev = lldev->devh;
        int ret;

        xge_debug_ll(XGE_TRACE, "%s%d: M_START", XGELL_IFNAME,
            lldev->instance);

        mutex_enter(&lldev->genlock);

        if (lldev->is_initialized) {
                xge_debug_ll(XGE_ERR, "%s%d: device is already initialized",
                    XGELL_IFNAME, lldev->instance);
                mutex_exit(&lldev->genlock);
                return (EINVAL);
        }

        hldev->terminating = 0;
        if (ret = xgell_initiate_start(lldev)) {
                mutex_exit(&lldev->genlock);
                return (ret);
        }

        lldev->timeout_id = timeout(xge_device_poll, hldev, XGE_DEV_POLL_TICKS);

        mutex_exit(&lldev->genlock);

        return (0);
}

/*
 * xgell_m_stop
 * @arg: pointer to device private data (hldev)
 *
 * This function is called by the MAC Layer to disable
 * the XFRAME firmware for generating any interrupts and
 * also stop the driver from calling mac_rx() for
 * delivering data packets to the MAC Layer.
 */
static void
xgell_m_stop(void *arg)
{
        xgelldev_t *lldev = arg;
        xge_hal_device_t *hldev = lldev->devh;

        xge_debug_ll(XGE_TRACE, "%s", "MAC_STOP");

        mutex_enter(&lldev->genlock);
        if (!lldev->is_initialized) {
                xge_debug_ll(XGE_ERR, "%s", "device is not initialized...");
                mutex_exit(&lldev->genlock);
                return;
        }

        xge_hal_device_terminating(hldev);
        xgell_initiate_stop(lldev);

        /* reset device */
        (void) xge_hal_device_reset(lldev->devh);

        mutex_exit(&lldev->genlock);

        if (lldev->timeout_id != 0) {
                (void) untimeout(lldev->timeout_id);
        }

        xge_debug_ll(XGE_TRACE, "%s", "returning back to MAC Layer...");
}

/*
 * xgell_onerr_reset
 * @lldev: pointer to xgelldev_t structure
 *
 * This function is called by HAL Event framework to reset the HW
 * This function is must be called with genlock taken.
 */
int
xgell_onerr_reset(xgelldev_t *lldev)
{
        int rc = 0;

        if (!lldev->is_initialized) {
                xge_debug_ll(XGE_ERR, "%s%d: can not reset",
                    XGELL_IFNAME, lldev->instance);
                return (rc);
        }

        lldev->in_reset = 1;
        xgell_initiate_stop(lldev);

        /* reset device */
        (void) xge_hal_device_reset(lldev->devh);

        rc = xgell_initiate_start(lldev);
        lldev->in_reset = 0;

        return (rc);
}

/*
 * xgell_m_multicst
 * @arg: pointer to device private strucutre(hldev)
 * @add:
 * @mc_addr:
 *
 * This function is called by MAC Layer to enable or
 * disable device-level reception of specific multicast addresses.
 */
static int
xgell_m_multicst(void *arg, boolean_t add, const uint8_t *mc_addr)
{
        xge_hal_status_e status;
        xgelldev_t *lldev = (xgelldev_t *)arg;
        xge_hal_device_t *hldev = lldev->devh;

        xge_debug_ll(XGE_TRACE, "M_MULTICAST add %d", add);

        mutex_enter(&lldev->genlock);

        if (!lldev->is_initialized) {
                xge_debug_ll(XGE_ERR, "%s%d: can not set multicast",
                    XGELL_IFNAME, lldev->instance);
                mutex_exit(&lldev->genlock);
                return (EIO);
        }

        /* FIXME: missing HAL functionality: enable_one() */

        status = (add) ?
            xge_hal_device_mcast_enable(hldev) :
            xge_hal_device_mcast_disable(hldev);

        if (status != XGE_HAL_OK) {
                xge_debug_ll(XGE_ERR, "failed to %s multicast, status %d",
                    add ? "enable" : "disable", status);
                mutex_exit(&lldev->genlock);
                return (EIO);
        }

        mutex_exit(&lldev->genlock);

        return (0);
}


/*
 * xgell_m_promisc
 * @arg: pointer to device private strucutre(hldev)
 * @on:
 *
 * This function is called by MAC Layer to enable or
 * disable the reception of all the packets on the medium
 */
static int
xgell_m_promisc(void *arg, boolean_t on)
{
        xgelldev_t *lldev = (xgelldev_t *)arg;
        xge_hal_device_t *hldev = lldev->devh;

        mutex_enter(&lldev->genlock);

        xge_debug_ll(XGE_TRACE, "%s", "MAC_PROMISC_SET");

        if (!lldev->is_initialized) {
                xge_debug_ll(XGE_ERR, "%s%d: can not set promiscuous",
                    XGELL_IFNAME, lldev->instance);
                mutex_exit(&lldev->genlock);
                return (EIO);
        }

        if (on) {
                xge_hal_device_promisc_enable(hldev);
        } else {
                xge_hal_device_promisc_disable(hldev);
        }

        mutex_exit(&lldev->genlock);

        return (0);
}

/*
 * xgell_m_stat
 * @arg: pointer to device private strucutre(hldev)
 *
 * This function is called by MAC Layer to get network statistics
 * from the driver.
 */
static int
xgell_m_stat(void *arg, uint_t stat, uint64_t *val)
{
        xge_hal_stats_hw_info_t *hw_info;
        xgelldev_t *lldev = (xgelldev_t *)arg;
        xge_hal_device_t *hldev = lldev->devh;

        xge_debug_ll(XGE_TRACE, "%s", "MAC_STATS_GET");

        mutex_enter(&lldev->genlock);

        if (!lldev->is_initialized) {
                mutex_exit(&lldev->genlock);
                return (EAGAIN);
        }

        if (xge_hal_stats_hw(hldev, &hw_info) != XGE_HAL_OK) {
                mutex_exit(&lldev->genlock);
                return (EAGAIN);
        }

        switch (stat) {
        case MAC_STAT_IFSPEED:
                *val = 10000000000ull; /* 10G */
                break;

        case MAC_STAT_MULTIRCV:
                *val = ((u64) hw_info->rmac_vld_mcst_frms_oflow << 32) |
                    hw_info->rmac_vld_mcst_frms;
                break;

        case MAC_STAT_BRDCSTRCV:
                *val = ((u64) hw_info->rmac_vld_bcst_frms_oflow << 32) |
                    hw_info->rmac_vld_bcst_frms;
                break;

        case MAC_STAT_MULTIXMT:
                *val = ((u64) hw_info->tmac_mcst_frms_oflow << 32) |
                    hw_info->tmac_mcst_frms;
                break;

        case MAC_STAT_BRDCSTXMT:
                *val = ((u64) hw_info->tmac_bcst_frms_oflow << 32) |
                    hw_info->tmac_bcst_frms;
                break;

        case MAC_STAT_RBYTES:
                *val = ((u64) hw_info->rmac_ttl_octets_oflow << 32) |
                    hw_info->rmac_ttl_octets;
                break;

        case MAC_STAT_NORCVBUF:
                *val = hw_info->rmac_drop_frms;
                break;

        case MAC_STAT_IERRORS:
                *val = ((u64) hw_info->rmac_discarded_frms_oflow << 32) |
                    hw_info->rmac_discarded_frms;
                break;

        case MAC_STAT_OBYTES:
                *val = ((u64) hw_info->tmac_ttl_octets_oflow << 32) |
                    hw_info->tmac_ttl_octets;
                break;

        case MAC_STAT_NOXMTBUF:
                *val = hw_info->tmac_drop_frms;
                break;

        case MAC_STAT_OERRORS:
                *val = ((u64) hw_info->tmac_any_err_frms_oflow << 32) |
                    hw_info->tmac_any_err_frms;
                break;

        case MAC_STAT_IPACKETS:
                *val = ((u64) hw_info->rmac_vld_frms_oflow << 32) |
                    hw_info->rmac_vld_frms;
                break;

        case MAC_STAT_OPACKETS:
                *val = ((u64) hw_info->tmac_frms_oflow << 32) |
                    hw_info->tmac_frms;
                break;

        case ETHER_STAT_FCS_ERRORS:
                *val = hw_info->rmac_fcs_err_frms;
                break;

        case ETHER_STAT_TOOLONG_ERRORS:
                *val = hw_info->rmac_long_frms;
                break;

        case ETHER_STAT_LINK_DUPLEX:
                *val = LINK_DUPLEX_FULL;
                break;

        default:
                mutex_exit(&lldev->genlock);
                return (ENOTSUP);
        }

        mutex_exit(&lldev->genlock);

        return (0);
}

/*
 * Retrieve a value for one of the statistics for a particular rx ring
 */
int
xgell_rx_ring_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val)
{
        xgell_rx_ring_t *rx_ring = (xgell_rx_ring_t *)rh;

        switch (stat) {
        case MAC_STAT_RBYTES:
                *val = rx_ring->rx_bytes;
                break;

        case MAC_STAT_IPACKETS:
                *val = rx_ring->rx_pkts;
                break;

        default:
                *val = 0;
                return (ENOTSUP);
        }

        return (0);
}

/*
 * Retrieve a value for one of the statistics for a particular tx ring
 */
int
xgell_tx_ring_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val)
{
        xgell_tx_ring_t *tx_ring = (xgell_tx_ring_t *)rh;

        switch (stat) {
        case MAC_STAT_OBYTES:
                *val = tx_ring->tx_bytes;
                break;

        case MAC_STAT_OPACKETS:
                *val = tx_ring->tx_pkts;
                break;

        default:
                *val = 0;
                return (ENOTSUP);
        }

        return (0);
}

/*
 * xgell_device_alloc - Allocate new LL device
 */
int
xgell_device_alloc(xge_hal_device_h devh,
    dev_info_t *dev_info, xgelldev_t **lldev_out)
{
        xgelldev_t *lldev;
        xge_hal_device_t *hldev = (xge_hal_device_t *)devh;
        int instance = ddi_get_instance(dev_info);

        *lldev_out = NULL;

        xge_debug_ll(XGE_TRACE, "trying to register etherenet device %s%d...",
            XGELL_IFNAME, instance);

        lldev = kmem_zalloc(sizeof (xgelldev_t), KM_SLEEP);

        lldev->devh = hldev;
        lldev->instance = instance;
        lldev->dev_info = dev_info;

        *lldev_out = lldev;

        ddi_set_driver_private(dev_info, (caddr_t)hldev);

        return (DDI_SUCCESS);
}

/*
 * xgell_device_free
 */
void
xgell_device_free(xgelldev_t *lldev)
{
        xge_debug_ll(XGE_TRACE, "freeing device %s%d",
            XGELL_IFNAME, lldev->instance);

        kmem_free(lldev, sizeof (xgelldev_t));
}

/*
 * xgell_ioctl
 */
static void
xgell_m_ioctl(void *arg, queue_t *wq, mblk_t *mp)
{
        xgelldev_t *lldev = arg;
        struct iocblk *iocp;
        int err = 0;
        int cmd;
        int need_privilege = 1;
        int ret = 0;


        iocp = (struct iocblk *)mp->b_rptr;
        iocp->ioc_error = 0;
        cmd = iocp->ioc_cmd;
        xge_debug_ll(XGE_TRACE, "MAC_IOCTL cmd 0x%x", cmd);
        switch (cmd) {
        case ND_GET:
                need_privilege = 0;
                /* FALLTHRU */
        case ND_SET:
                break;
        default:
                xge_debug_ll(XGE_TRACE, "unknown cmd 0x%x", cmd);
                miocnak(wq, mp, 0, EINVAL);
                return;
        }

        if (need_privilege) {
                err = secpolicy_net_config(iocp->ioc_cr, B_FALSE);
                if (err != 0) {
                        xge_debug_ll(XGE_ERR,
                            "drv_priv(): rejected cmd 0x%x, err %d",
                            cmd, err);
                        miocnak(wq, mp, 0, err);
                        return;
                }
        }

        switch (cmd) {
        case ND_GET:
                /*
                 * If nd_getset() returns B_FALSE, the command was
                 * not valid (e.g. unknown name), so we just tell the
                 * top-level ioctl code to send a NAK (with code EINVAL).
                 *
                 * Otherwise, nd_getset() will have built the reply to
                 * be sent (but not actually sent it), so we tell the
                 * caller to send the prepared reply.
                 */
                ret = nd_getset(wq, lldev->ndp, mp);
                xge_debug_ll(XGE_TRACE, "%s", "got ndd get ioctl");
                break;

        case ND_SET:
                ret = nd_getset(wq, lldev->ndp, mp);
                xge_debug_ll(XGE_TRACE, "%s", "got ndd set ioctl");
                break;

        default:
                break;
        }

        if (ret == B_FALSE) {
                xge_debug_ll(XGE_ERR,
                    "nd_getset(): rejected cmd 0x%x, err %d",
                    cmd, err);
                miocnak(wq, mp, 0, EINVAL);
        } else {
                mp->b_datap->db_type = iocp->ioc_error == 0 ?
                    M_IOCACK : M_IOCNAK;
                qreply(wq, mp);
        }
}


static boolean_t
xgell_m_getcapab(void *arg, mac_capab_t cap, void *cap_data)
{
        xgelldev_t *lldev = arg;

        xge_debug_ll(XGE_TRACE, "xgell_m_getcapab: %x", cap);

        switch (cap) {
        case MAC_CAPAB_HCKSUM: {
                uint32_t *hcksum_txflags = cap_data;
                *hcksum_txflags = HCKSUM_INET_FULL_V4 | HCKSUM_INET_FULL_V6 |
                    HCKSUM_IPHDRCKSUM;
                break;
        }
        case MAC_CAPAB_LSO: {
                mac_capab_lso_t *cap_lso = cap_data;

                if (lldev->config.lso_enable) {
                        cap_lso->lso_flags = LSO_TX_BASIC_TCP_IPV4;
                        cap_lso->lso_basic_tcp_ipv4.lso_max = XGELL_LSO_MAXLEN;
                        break;
                } else {
                        return (B_FALSE);
                }
        }
        case MAC_CAPAB_RINGS: {
                mac_capab_rings_t *cap_rings = cap_data;

                switch (cap_rings->mr_type) {
                case MAC_RING_TYPE_RX:
                        cap_rings->mr_group_type = MAC_GROUP_TYPE_STATIC;
                        cap_rings->mr_rnum = lldev->init_rx_rings;
                        cap_rings->mr_gnum = lldev->init_rx_groups;
                        cap_rings->mr_rget = xgell_fill_ring;
                        cap_rings->mr_gget = xgell_fill_group;
                        break;
                case MAC_RING_TYPE_TX:
                        cap_rings->mr_group_type = MAC_GROUP_TYPE_STATIC;
                        cap_rings->mr_rnum = lldev->init_tx_rings;
                        cap_rings->mr_gnum = 0;
                        cap_rings->mr_rget = xgell_fill_ring;
                        cap_rings->mr_gget = NULL;
                        break;
                default:
                        break;
                }
                break;
        }
        default:
                return (B_FALSE);
        }
        return (B_TRUE);
}

static int
xgell_stats_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp)
{
        xgelldev_t *lldev = (xgelldev_t *)cp;
        xge_hal_status_e status;
        int count = 0, retsize;
        char *buf;

        buf = kmem_alloc(XGELL_STATS_BUFSIZE, KM_SLEEP);
        if (buf == NULL) {
                return (ENOSPC);
        }

        status = xge_hal_aux_stats_tmac_read(lldev->devh, XGELL_STATS_BUFSIZE,
            buf, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_STATS_BUFSIZE);
                xge_debug_ll(XGE_ERR, "tmac_read(): status %d", status);
                return (EINVAL);
        }
        count += retsize;

        status = xge_hal_aux_stats_rmac_read(lldev->devh,
            XGELL_STATS_BUFSIZE - count,
            buf+count, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_STATS_BUFSIZE);
                xge_debug_ll(XGE_ERR, "rmac_read(): status %d", status);
                return (EINVAL);
        }
        count += retsize;

        status = xge_hal_aux_stats_pci_read(lldev->devh,
            XGELL_STATS_BUFSIZE - count, buf + count, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_STATS_BUFSIZE);
                xge_debug_ll(XGE_ERR, "pci_read(): status %d", status);
                return (EINVAL);
        }
        count += retsize;

        status = xge_hal_aux_stats_sw_dev_read(lldev->devh,
            XGELL_STATS_BUFSIZE - count, buf + count, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_STATS_BUFSIZE);
                xge_debug_ll(XGE_ERR, "sw_dev_read(): status %d", status);
                return (EINVAL);
        }
        count += retsize;

        status = xge_hal_aux_stats_hal_read(lldev->devh,
            XGELL_STATS_BUFSIZE - count, buf + count, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_STATS_BUFSIZE);
                xge_debug_ll(XGE_ERR, "pci_read(): status %d", status);
                return (EINVAL);
        }
        count += retsize;

        *(buf + count - 1) = '\0'; /* remove last '\n' */
        (void) mi_mpprintf(mp, "%s", buf);
        kmem_free(buf, XGELL_STATS_BUFSIZE);

        return (0);
}

static int
xgell_pciconf_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp)
{
        xgelldev_t *lldev = (xgelldev_t *)cp;
        xge_hal_status_e status;
        int retsize;
        char *buf;

        buf = kmem_alloc(XGELL_PCICONF_BUFSIZE, KM_SLEEP);
        if (buf == NULL) {
                return (ENOSPC);
        }
        status = xge_hal_aux_pci_config_read(lldev->devh, XGELL_PCICONF_BUFSIZE,
            buf, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_PCICONF_BUFSIZE);
                xge_debug_ll(XGE_ERR, "pci_config_read(): status %d", status);
                return (EINVAL);
        }
        *(buf + retsize - 1) = '\0'; /* remove last '\n' */
        (void) mi_mpprintf(mp, "%s", buf);
        kmem_free(buf, XGELL_PCICONF_BUFSIZE);

        return (0);
}

static int
xgell_about_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp)
{
        xgelldev_t *lldev = (xgelldev_t *)cp;
        xge_hal_status_e status;
        int retsize;
        char *buf;

        buf = kmem_alloc(XGELL_ABOUT_BUFSIZE, KM_SLEEP);
        if (buf == NULL) {
                return (ENOSPC);
        }
        status = xge_hal_aux_about_read(lldev->devh, XGELL_ABOUT_BUFSIZE,
            buf, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_ABOUT_BUFSIZE);
                xge_debug_ll(XGE_ERR, "about_read(): status %d", status);
                return (EINVAL);
        }
        *(buf + retsize - 1) = '\0'; /* remove last '\n' */
        (void) mi_mpprintf(mp, "%s", buf);
        kmem_free(buf, XGELL_ABOUT_BUFSIZE);

        return (0);
}

static unsigned long bar0_offset = 0x110; /* adapter_control */

static int
xgell_bar0_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp)
{
        xgelldev_t *lldev = (xgelldev_t *)cp;
        xge_hal_status_e status;
        int retsize;
        char *buf;

        buf = kmem_alloc(XGELL_IOCTL_BUFSIZE, KM_SLEEP);
        if (buf == NULL) {
                return (ENOSPC);
        }
        status = xge_hal_aux_bar0_read(lldev->devh, bar0_offset,
            XGELL_IOCTL_BUFSIZE, buf, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_IOCTL_BUFSIZE);
                xge_debug_ll(XGE_ERR, "bar0_read(): status %d", status);
                return (EINVAL);
        }
        *(buf + retsize - 1) = '\0'; /* remove last '\n' */
        (void) mi_mpprintf(mp, "%s", buf);
        kmem_free(buf, XGELL_IOCTL_BUFSIZE);

        return (0);
}

static int
xgell_bar0_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, cred_t *credp)
{
        unsigned long old_offset = bar0_offset;
        char *end;

        if (value && *value == '0' &&
            (*(value + 1) == 'x' || *(value + 1) == 'X')) {
                value += 2;
        }

        bar0_offset = mi_strtol(value, &end, 16);
        if (end == value) {
                bar0_offset = old_offset;
                return (EINVAL);
        }

        xge_debug_ll(XGE_TRACE, "bar0: new value %s:%lX", value, bar0_offset);

        return (0);
}

static int
xgell_debug_level_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp)
{
        char *buf;

        buf = kmem_alloc(XGELL_IOCTL_BUFSIZE, KM_SLEEP);
        if (buf == NULL) {
                return (ENOSPC);
        }
        (void) mi_mpprintf(mp, "debug_level %d", xge_hal_driver_debug_level());
        kmem_free(buf, XGELL_IOCTL_BUFSIZE);

        return (0);
}

static int
xgell_debug_level_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp,
    cred_t *credp)
{
        int level;
        char *end;

        level = mi_strtol(value, &end, 10);
        if (level < XGE_NONE || level > XGE_ERR || end == value) {
                return (EINVAL);
        }

        xge_hal_driver_debug_level_set(level);

        return (0);
}

static int
xgell_debug_module_mask_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp)
{
        char *buf;

        buf = kmem_alloc(XGELL_IOCTL_BUFSIZE, KM_SLEEP);
        if (buf == NULL) {
                return (ENOSPC);
        }
        (void) mi_mpprintf(mp, "debug_module_mask 0x%08x",
            xge_hal_driver_debug_module_mask());
        kmem_free(buf, XGELL_IOCTL_BUFSIZE);

        return (0);
}

static int
xgell_debug_module_mask_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp,
                            cred_t *credp)
{
        u32 mask;
        char *end;

        if (value && *value == '0' &&
            (*(value + 1) == 'x' || *(value + 1) == 'X')) {
                value += 2;
        }

        mask = mi_strtol(value, &end, 16);
        if (end == value) {
                return (EINVAL);
        }

        xge_hal_driver_debug_module_mask_set(mask);

        return (0);
}

static int
xgell_devconfig_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp)
{
        xgelldev_t *lldev = (xgelldev_t *)(void *)cp;
        xge_hal_status_e status;
        int retsize;
        char *buf;

        buf = kmem_alloc(XGELL_DEVCONF_BUFSIZE, KM_SLEEP);
        if (buf == NULL) {
                return (ENOSPC);
        }
        status = xge_hal_aux_device_config_read(lldev->devh,
            XGELL_DEVCONF_BUFSIZE, buf, &retsize);
        if (status != XGE_HAL_OK) {
                kmem_free(buf, XGELL_DEVCONF_BUFSIZE);
                xge_debug_ll(XGE_ERR, "device_config_read(): status %d",
                    status);
                return (EINVAL);
        }
        *(buf + retsize - 1) = '\0'; /* remove last '\n' */
        (void) mi_mpprintf(mp, "%s", buf);
        kmem_free(buf, XGELL_DEVCONF_BUFSIZE);

        return (0);
}

/*
 * xgell_device_register
 * @devh: pointer on HAL device
 * @config: pointer on this network device configuration
 * @ll_out: output pointer. Will be assigned to valid LL device.
 *
 * This function will allocate and register network device
 */
int
xgell_device_register(xgelldev_t *lldev, xgell_config_t *config)
{
        mac_register_t *macp = NULL;
        xge_hal_device_t *hldev = (xge_hal_device_t *)lldev->devh;

        /*
         * Initialize some NDD interface for internal debug.
         */
        if (nd_load(&lldev->ndp, "pciconf", xgell_pciconf_get, NULL,
            (caddr_t)lldev) == B_FALSE)
                goto xgell_ndd_fail;

        if (nd_load(&lldev->ndp, "about", xgell_about_get, NULL,
            (caddr_t)lldev) == B_FALSE)
                goto xgell_ndd_fail;

        if (nd_load(&lldev->ndp, "stats", xgell_stats_get, NULL,
            (caddr_t)lldev) == B_FALSE)
                goto xgell_ndd_fail;

        if (nd_load(&lldev->ndp, "bar0", xgell_bar0_get, xgell_bar0_set,
            (caddr_t)lldev) == B_FALSE)
                goto xgell_ndd_fail;

        if (nd_load(&lldev->ndp, "debug_level", xgell_debug_level_get,
            xgell_debug_level_set, (caddr_t)lldev) == B_FALSE)
                goto xgell_ndd_fail;

        if (nd_load(&lldev->ndp, "debug_module_mask",
            xgell_debug_module_mask_get, xgell_debug_module_mask_set,
            (caddr_t)lldev) == B_FALSE)
                goto xgell_ndd_fail;

        if (nd_load(&lldev->ndp, "devconfig", xgell_devconfig_get, NULL,
            (caddr_t)lldev) == B_FALSE)
                goto xgell_ndd_fail;

        bcopy(config, &lldev->config, sizeof (xgell_config_t));

        mutex_init(&lldev->genlock, NULL, MUTEX_DRIVER,
            DDI_INTR_PRI(hldev->irqh));

        if ((macp = mac_alloc(MAC_VERSION)) == NULL)
                goto xgell_register_fail;
        macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
        macp->m_driver = lldev;
        macp->m_dip = lldev->dev_info;
        macp->m_src_addr = hldev->macaddr[0];
        macp->m_callbacks = &xgell_m_callbacks;
        macp->m_min_sdu = 0;
        macp->m_max_sdu = hldev->config.mtu;
        macp->m_margin = VLAN_TAGSZ;
        macp->m_v12n = MAC_VIRT_LEVEL1;

        /*
         * MAC Registration.
         */
        if (mac_register(macp, &lldev->mh) != 0)
                goto xgell_register_fail;

        /* Always free the macp after register */
        if (macp != NULL)
                mac_free(macp);

        /* Calculate tx_copied_max here ??? */
        lldev->tx_copied_max = hldev->config.fifo.max_frags *
            hldev->config.fifo.alignment_size *
            hldev->config.fifo.max_aligned_frags;

        xge_debug_ll(XGE_TRACE, "etherenet device %s%d registered",
            XGELL_IFNAME, lldev->instance);

        return (DDI_SUCCESS);

xgell_ndd_fail:
        nd_free(&lldev->ndp);
        xge_debug_ll(XGE_ERR, "%s", "unable to load ndd parameter");
        return (DDI_FAILURE);

xgell_register_fail:
        if (macp != NULL)
                mac_free(macp);
        nd_free(&lldev->ndp);
        mutex_destroy(&lldev->genlock);
        xge_debug_ll(XGE_ERR, "%s", "unable to register networking device");
        return (DDI_FAILURE);
}

/*
 * xgell_device_unregister
 * @devh: pointer on HAL device
 * @lldev: pointer to valid LL device.
 *
 * This function will unregister and free network device
 */
int
xgell_device_unregister(xgelldev_t *lldev)
{
        if (mac_unregister(lldev->mh) != 0) {
                xge_debug_ll(XGE_ERR, "unable to unregister device %s%d",
                    XGELL_IFNAME, lldev->instance);
                return (DDI_FAILURE);
        }

        mutex_destroy(&lldev->genlock);

        nd_free(&lldev->ndp);

        xge_debug_ll(XGE_TRACE, "etherenet device %s%d unregistered",
            XGELL_IFNAME, lldev->instance);

        return (DDI_SUCCESS);
}