/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_NGE_H
#define _SYS_NGE_H

#ifdef __cplusplus
extern "C" {
#endif


#include <sys/types.h>
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/strsubr.h>
#include <sys/stat.h>
#include <sys/pci.h>
#include <sys/note.h>
#include <sys/modctl.h>
#include <sys/kstat.h>
#include <sys/ethernet.h>
#include <sys/pattr.h>
#include <sys/errno.h>
#include <sys/dlpi.h>
#include <sys/devops.h>
#include <sys/debug.h>
#include <sys/conf.h>
#include <sys/callb.h>

#include <netinet/ip6.h>

#include <inet/common.h>
#include <inet/ip.h>
#include <netinet/udp.h>
#include <inet/mi.h>
#include <inet/nd.h>

#include <sys/ddi.h>
#include <sys/sunddi.h>

#include <sys/mac_provider.h>
#include <sys/mac_ether.h>

/*
 * Reconfiguring the network devices requires the net_config privilege
 * in Solaris 10+.
 */
extern int secpolicy_net_config(const cred_t *, boolean_t);

#include <sys/netlb.h>
#include <sys/miiregs.h>

#include "nge_chip.h"

#define PIO_ADDR(ngep, offset)  ((void *)((caddr_t)(ngep)->io_regs+(offset)))
/*
 * Copy an ethernet address
 */
#define ethaddr_copy(src, dst)  bcopy((src), (dst), ETHERADDRL)
#define ether_eq(a, b) (bcmp((caddr_t)(a), (caddr_t)(b), (ETHERADDRL)) == 0)

#define BIS(w, b)       (((w) & (b)) ? B_TRUE : B_FALSE)
#define BIC(w, b)       (((w) & (b)) ? B_FALSE : B_TRUE)
#define UPORDOWN(x)     ((x) ? "up" : "down")

#define NGE_DRIVER_NAME         "nge"

/*
 * 'Progress' bit flags ...
 */
#define PROGRESS_CFG            0x0001  /* config space mapped          */
#define PROGRESS_REGS           0x0002  /* registers mapped             */
#define PROGRESS_BUFS           0x0004  /* registers mapped             */
#define PROGRESS_RESCHED        0x0008  /* resched softint registered   */
#define PROGRESS_FACTOTUM       0x0010  /* factotum softint registered  */
#define PROGRESS_SWINT          0x0020  /* s/w interrupt registered     */
#define PROGRESS_INTR           0x0040  /* h/w interrupt registered     */
                                        /* and mutexen initialised      */
#define PROGRESS_HWINT          0x0080
#define PROGRESS_PHY            0x0100  /* PHY initialised              */
#define PROGRESS_NDD            0x0200  /* NDD parameters set up        */
#define PROGRESS_KSTATS         0x0400  /* kstats created               */
#define PROGRESS_READY          0x0800  /* ready for work               */

#define NGE_HW_ERR              0x00
#define NGE_HW_LINK             0x01
#define NGE_HW_BM               0x02
#define NGE_HW_RCHAN            0x03
#define NGE_HW_TCHAN            0x04
#define NGE_HW_ROM              0x05
#define NGE_SW_PROBLEM_ID       0x06


/*
 * NOTES:
 *
 * #defines:
 *
 *      NGE_PCI_CONFIG_RNUMBER and NGE_PCI_OPREGS_RNUMBER are the
 *      register-set numbers to use for the config space registers
 *      and the operating registers respectively.  On an OBP-based
 *      machine, regset 0 refers to CONFIG space, and regset 1 will
 *      be the operating registers in MEMORY space.  If an expansion
 *      ROM is fitted, it may appear as a further register set.
 *
 *      NGE_DMA_MODE defines the mode (STREAMING/CONSISTENT) used
 *      for the data buffers.  The descriptors are always set up
 *      in CONSISTENT mode.
 *
 *      NGE_HEADROOM defines how much space we'll leave in allocated
 *      mblks before the first valid data byte.  This should be chosen
 *      to be 2 modulo 4, so that once the ethernet header (14 bytes)
 *      has been stripped off, the packet data will be 4-byte aligned.
 *      The remaining space can be used by upstream modules to prepend
 *      any headers required.
 */


#define NGE_PCI_OPREGS_RNUMBER  1
#define NGE_DMA_MODE            DDI_DMA_STREAMING
#define NGE_HEADROOM            6
#define ETHER_HEAD_LEN          14
#ifndef VTAG_SIZE
#define VTAG_SIZE               4
#endif

#define NGE_CYCLIC_PERIOD       (1000000000)

#define NGE_DEFAULT_MTU         1500
#define NGE_DEFAULT_SDU         1518
#define NGE_MTU_2500            2500
#define NGE_MTU_4500            4500
#define NGE_MAX_MTU             9000
#define NGE_MAX_SDU             9018

#define NGE_DESC_MIN            0x200

#define NGE_STD_BUFSZ           1792
#define NGE_JB2500_BUFSZ        (3*1024)
#define NGE_JB4500_BUFSZ        (5*1024)
#define NGE_JB9000_BUFSZ        (9*1024)

#define NGE_SEND_SLOTS_DESC_1024        1024
#define NGE_SEND_SLOTS_DESC_3072        3072
#define NGE_SEND_JB2500_SLOTS_DESC      3072
#define NGE_SEND_JB4500_SLOTS_DESC      2048
#define NGE_SEND_JB9000_SLOTS_DESC      1024
#define NGE_SEND_LOWMEM_SLOTS_DESC      1024
#define NGE_SEND_SLOTS_BUF              3072

#define NGE_RECV_SLOTS_DESC_1024        1024
#define NGE_RECV_SLOTS_DESC_3072        3072
#define NGE_RECV_JB2500_SLOTS_DESC      3072
#define NGE_RECV_JB4500_SLOTS_DESC      2048
#define NGE_RECV_JB9000_SLOTS_DESC      1024
#define NGE_RECV_LOWMEM_SLOTS_DESC      1024
#define NGE_RECV_SLOTS_BUF              6144

#define NGE_SPLIT_32            32
#define NGE_SPLIT_96            96
#define NGE_SPLIT_256           256

#define NGE_RX_COPY_SIZE        512
#define NGE_TX_COPY_SIZE        512
#define NGE_MAP_FRAGS           3
#define NGE_MAX_COOKIES         3
#define NGE_MAX_DMA_HDR         (4*1024)

/* Used by interrupt moderation */
#define NGE_TFINT_DEFAULT       32
#define NGE_POLL_TUNE           80000
#define NGE_POLL_ENTER          10000
#define NGE_POLL_MAX            1280000
#define NGE_POLL_QUIET_TIME     100
#define NGE_POLL_BUSY_TIME      2

/*
 * NGE-specific ioctls ...
 */
#define NGE_IOC                 ((((('N' << 8) + 'G') << 8) + 'E') << 8)

/*
 * PHY register read/write ioctls, used by cable test software
 */
#define NGE_MII_READ            (NGE_IOC|1)
#define NGE_MII_WRITE           (NGE_IOC|2)

/*
 * SEEPROM read/write ioctls, for use by SEEPROM upgrade utility
 *
 * Note: SEEPROMs can only be accessed as 32-bit words, so <see_addr>
 * must be a multiple of 4.  Not all systems have a SEEPROM fitted!
 */
#define NGE_SEE_READ            (NGE_IOC|3)
#define NGE_SEE_WRITE           (NGE_IOC|4)


/*
 * These diagnostic IOCTLS are enabled only in DEBUG drivers
 */
#define NGE_DIAG                (NGE_IOC|5)     /* currently a no-op    */
#define NGE_PEEK                (NGE_IOC|6)
#define NGE_POKE                (NGE_IOC|7)
#define NGE_PHY_RESET           (NGE_IOC|8)
#define NGE_SOFT_RESET          (NGE_IOC|9)
#define NGE_HARD_RESET          (NGE_IOC|10)


enum NGE_HW_OP {
        NGE_CLEAR = 0,
        NGE_SET
};

/*
 * Required state according to GLD
 */
enum nge_mac_state {
        NGE_MAC_UNKNOWN,
        NGE_MAC_RESET,
        NGE_MAC_STOPPED,
        NGE_MAC_STARTED,
        NGE_MAC_UNATTACH
};
enum loop_type {
        NGE_LOOP_NONE = 0,
        NGE_LOOP_EXTERNAL_100,
        NGE_LOOP_EXTERNAL_10,
        NGE_LOOP_INTERNAL_PHY,
};

/*
 * (Internal) return values from send_msg subroutines
 */
enum send_status {
        SEND_COPY_FAIL = -1,            /* => GLD_NORESOURCES   */
        SEND_MAP_FAIL,                  /* => GLD_NORESOURCES   */
        SEND_COPY_SUCESS,               /* OK, msg queued       */
        SEND_MAP_SUCCESS                /* OK, free msg         */
};

/*
 * (Internal) return values from ioctl subroutines
 */
enum ioc_reply {
        IOC_INVAL = -1,                 /* bad, NAK with EINVAL */
        IOC_DONE,                       /* OK, reply sent       */
        IOC_ACK,                        /* OK, just send ACK    */
        IOC_REPLY,                      /* OK, just send reply  */
        IOC_RESTART_ACK,                /* OK, restart & ACK    */
        IOC_RESTART_REPLY               /* OK, restart & reply  */
};

enum nge_pp_type {
        NGE_PP_SPACE_CFG = 0,
        NGE_PP_SPACE_REG,
        NGE_PP_SPACE_NIC,
        NGE_PP_SPACE_MII,
        NGE_PP_SPACE_NGE,
        NGE_PP_SPACE_TXDESC,
        NGE_PP_SPACE_TXBUFF,
        NGE_PP_SPACE_RXDESC,
        NGE_PP_SPACE_RXBUFF,
        NGE_PP_SPACE_STATISTICS,
        NGE_PP_SPACE_SEEPROM,
        NGE_PP_SPACE_FLASH
};

/*
 * Flag to kstat type
 */
enum nge_kstat_type {
        NGE_KSTAT_RAW = 0,
        NGE_KSTAT_STATS,
        NGE_KSTAT_CHIPID,
        NGE_KSTAT_DEBUG,
        NGE_KSTAT_COUNT
};


/*
 * Actual state of the nvidia's chip
 */
enum nge_chip_state {
        NGE_CHIP_FAULT = -2,            /* fault, need reset    */
        NGE_CHIP_ERROR,                 /* error, want reset    */
        NGE_CHIP_INITIAL,               /* Initial state only   */
        NGE_CHIP_RESET,                 /* reset, need init     */
        NGE_CHIP_STOPPED,               /* Tx/Rx stopped        */
        NGE_CHIP_RUNNING                /* with interrupts      */
};

enum nge_eeprom_size {
        EEPROM_1K = 0,
        EEPROM_2K,
        EEPROM_4K,
        EEPROM_8K,
        EEPROM_16K,
        EEPROM_32K,
        EEPROM_64K
};

enum nge_eeprom_access_wid {
        ACCESS_8BIT = 0,
        ACCESS_16BIT
};

/*
 * MDIO operation
 */
enum nge_mdio_operation {
        NGE_MDIO_READ = 0,
        NGE_MDIO_WRITE
};

/*
 * Speed selection
 */
enum nge_speed {
        UNKOWN_SPEED = 0,
        NGE_10M,
        NGE_100M,
        NGE_1000M
};

/*
 * Duplex selection
 */
enum nge_duplex {
        UNKOWN_DUPLEX = 0,
        NGE_HD,
        NGE_FD
};

typedef struct {
        ether_addr_t            addr;           /* in canonical form    */
        uint8_t                 spare;
        uint8_t                 set;            /* nonzero => valid     */
} nge_mac_addr_t;

struct nge;


#define CHIP_FLAG_COPPER        0x40

/*
 * Collection of physical-layer functions to:
 *      (re)initialise the physical layer
 *      update it to match software settings
 *      check for link status change
 */
typedef struct {
        boolean_t       (*phys_restart)(struct nge *);
        void            (*phys_update)(struct nge *);
        boolean_t       (*phys_check)(struct nge *);
} phys_ops_t;

struct nge_see_rw {
        uint32_t        see_addr;       /* Byte offset within SEEPROM   */
        uint32_t        see_data;       /* Data read/data to write      */
};

typedef struct {
        uint64_t        pp_acc_size;    /* in bytes: 1,2,4,8    */
        uint64_t        pp_acc_space;   /* See #defines below   */
        uint64_t        pp_acc_offset;
        uint64_t        pp_acc_data;    /* output for peek      */
                                        /* input for poke       */
} nge_peekpoke_t;

typedef uintptr_t       nge_regno_t;    /* register # (offset)  */

typedef struct _mul_list {
        struct _mul_list *next;
        uint32_t ref_cnt;
        ether_addr_t mul_addr;
}mul_item, *pmul_item;

/*
 * Describes one chunk of allocated DMA-able memory
 *
 * In some cases, this is a single chunk as allocated from the system;
 * but we also use this structure to represent slices carved off such
 * a chunk.  Even when we don't really need all the information, we
 * use this structure as a convenient way of correlating the various
 * ways of looking at a piece of memory (kernel VA, IO space DVMA,
 * handle+offset, etc).
 */
typedef struct dma_area
{

        caddr_t                 private;        /* pointer to nge */
        frtn_t                  rx_recycle;     /* recycle function */
        mblk_t                  *mp;
        ddi_acc_handle_t        acc_hdl;        /* handle for memory    */
        void                    *mem_va;        /* CPU VA of memory     */
        uint32_t                nslots;         /* number of slots      */
        uint32_t                size;           /* size per slot        */
        size_t                  alength;        /* allocated size       */
                                                /* >= product of above  */
        ddi_dma_handle_t        dma_hdl;        /* DMA handle           */
        offset_t                offset;         /* relative to handle   */
        ddi_dma_cookie_t        cookie;         /* associated cookie    */
        uint32_t                ncookies;
        uint32_t                signature;      /* buffer signature     */
                                                /* for deciding to free */
                                                /* or to reuse buffers  */
        boolean_t               rx_delivered;   /* hold by upper layer  */
        struct dma_area         *next;
} dma_area_t;

#define HOST_OWN        0x00000000
#define CONTROLER_OWN   0x00000001
#define NGE_END_PACKET  0x00000002


typedef struct nge_dmah_node
{
        struct nge_dmah_node    *next;
        ddi_dma_handle_t        hndl;
} nge_dmah_node_t;

typedef struct nge_dmah_list
{
        nge_dmah_node_t *head;
        nge_dmah_node_t *tail;
} nge_dmah_list_t;

/*
 * Software version of the Recv Descriptor
 * There's one of these for each recv buffer (up to 512 per ring)
 */
typedef struct sw_rx_sbd {

        dma_area_t              desc;           /* (const) related h/w  */
                                                /* descriptor area      */
        dma_area_t              *bufp;          /* (const) related      */
                                                /* buffer area          */
        uint8_t                 flags;
} sw_rx_sbd_t;

/*
 * Software version of the send Buffer Descriptor
 * There's one of these for each send buffer (up to 512 per ring)
 */
typedef struct sw_tx_sbd {

        dma_area_t              desc;           /* (const) related h/w  */
                                                /* descriptor area      */
        dma_area_t              pbuf;           /* (const) related      */
                                                /* buffer area          */
        void                    (*tx_recycle)(struct sw_tx_sbd *);
        uint32_t                flags;
        mblk_t                  *mp;            /* related mblk, if any */
        nge_dmah_list_t         mp_hndl;
        uint32_t                frags;
        uint32_t                ncookies;       /* dma cookie number */

} sw_tx_sbd_t;

/*
 * Software Receive Buffer (Producer) Ring Control Block
 * There's one of these for each receiver producer ring (up to 3),
 * but each holds buffers of a different size.
 */
typedef struct buff_ring {

        uint64_t                nslots;         /* descriptor area      */
        struct nge              *ngep;          /* (const) containing   */
                                                /* driver soft state    */
                                                /* initialise same      */
        uint64_t                rx_hold;
        sw_rx_sbd_t             *sw_rbds;       /* software descriptors */
        sw_rx_sbd_t             *free_rbds;     /* free ring */
        dma_area_t              *free_list;     /* available buffer queue */
        dma_area_t              *recycle_list;  /* recycling buffer queue */
        kmutex_t                recycle_lock[1];
        uint32_t                buf_sign;       /* buffer ring signature */
                                                /* for deciding to free  */
                                                /* or to reuse buffers   */
        boolean_t               rx_bcopy;
} buff_ring_t;

/*
 * Software Receive (Return) Ring Control Block
 * There's one of these for each receiver return ring (up to 16).
 */
typedef struct recv_ring {
        /*
         * The elements flagged (const) in the comments below are
         * set up once during initialiation and thereafter unchanged.
         */
        dma_area_t              desc;           /* (const) related h/w  */
                                                /* descriptor area      */
        struct nge              *ngep;          /* (const) containing   */
                                                /* driver soft state    */
        uint16_t                prod_index;     /* (const) ptr to h/w   */
                                                /* "producer index"     */
        mac_resource_handle_t   handle;
} recv_ring_t;



/*
 * Software Send Ring Control Block
 * There's one of these for each of (up to) 1 send rings
 */
typedef struct send_ring {
        /*
         * The elements flagged (const) in the comments below are
         * set up once during initialiation and thereafter unchanged.
         */
        dma_area_t              desc;           /* (const) related h/w  */
                                                /* descriptor area      */
        dma_area_t              buf[NGE_SEND_SLOTS_BUF];
                                                /* buffer area(s)       */
        struct nge              *ngep;          /* (const) containing   */
                                                /* driver soft state    */

        uint32_t                tx_hwmark;
        uint32_t                tx_lwmark;

        /*
         * The tx_lock must be held when updating
         * the s/w producer index
         * (tx_next)
         */
        kmutex_t                tx_lock[1];     /* serialize h/w update */
        uint32_t                tx_next;        /* next slot to use     */
        uint32_t                tx_flow;

        /*
         * These counters/indexes are manipulated in the transmit
         * path using atomics rather than mutexes for speed
         */
        uint32_t                tx_free;        /* # of slots available */

        /*
         * index (tc_next).
         */
        kmutex_t                tc_lock[1];
        uint32_t                tc_next;        /* next slot to recycle */
                                                /* ("consumer index")   */

        sw_tx_sbd_t             *sw_sbds;       /* software descriptors */

        kmutex_t                dmah_lock;
        nge_dmah_list_t         dmah_free;
        nge_dmah_node_t         dmahndl[NGE_MAX_DMA_HDR];

} send_ring_t;


typedef struct {
        uint32_t                businfo;        /* from private reg     */
        uint16_t                command;        /* saved during attach  */

        uint16_t                vendor;         /* vendor-id            */
        uint16_t                device;         /* device-id            */
        uint16_t                subven;         /* subsystem-vendor-id  */
        uint16_t                subdev;         /* subsystem-id         */
        uint8_t                 class_code;
        uint8_t                 revision;       /* revision-id          */
        uint8_t                 clsize;         /* cache-line-size      */
        uint8_t                 latency;        /* latency-timer        */
        uint8_t                 flags;

        uint16_t                phy_type;       /* Fiber module type    */
        uint64_t                hw_mac_addr;    /* from chip register   */
        nge_mac_addr_t          vendor_addr;    /* transform of same    */
} chip_info_t;


typedef struct {
        offset_t        index;
        char            *name;
} nge_ksindex_t;

typedef struct {
        uint64_t tso_err_mss;
        uint64_t tso_dis;
        uint64_t tso_err_nosum;
        uint64_t tso_err_hov;
        uint64_t tso_err_huf;
        uint64_t tso_err_l2;
        uint64_t tso_err_ip;
        uint64_t tso_err_l4;
        uint64_t tso_err_tcp;
        uint64_t hsum_err_ip;
        uint64_t hsum_err_l4;
}fe_statistics_t;

/*
 * statistics parameters to tune the driver
 */
typedef struct {
        uint64_t                intr_count;
        uint64_t                intr_lval;
        uint64_t                recv_realloc;
        uint64_t                poll_time;
        uint64_t                recy_free;
        uint64_t                recv_count;
        uint64_t                xmit_count;
        uint64_t                obytes;
        uint64_t                rbytes;
        uint64_t                mp_alloc_err;
        uint64_t                dma_alloc_err;
        uint64_t                kmem_alloc_err;
        uint64_t                load_context;
        uint64_t                ip_hwsum_err;
        uint64_t                tcp_hwsum_err;
        uint64_t                rx_nobuffer;
        uint64_t                rx_err;
        uint64_t                tx_stop_err;
        uint64_t                tx_stall;
        uint64_t                tx_rsrv_fail;
        uint64_t                tx_resched;
        fe_statistics_t fe_err;
}nge_sw_statistics_t;

typedef struct {
        nge_hw_statistics_t     hw_statistics;
        nge_sw_statistics_t     sw_statistics;
}nge_statistics_t;

struct nge_desc_attr    {

        size_t  rxd_size;
        size_t  txd_size;

        ddi_dma_attr_t  *dma_attr;
        ddi_dma_attr_t  *tx_dma_attr;

        void (*rxd_fill)(void *, const ddi_dma_cookie_t *, size_t);
        uint32_t (*rxd_check)(const void *, size_t *);

        void (*txd_fill)(void *, const ddi_dma_cookie_t *, size_t,
                        uint32_t, boolean_t, boolean_t);

        uint32_t (*txd_check)(const void *);
};

typedef struct nge_desc_attr nge_desc_attr_t;

/*
 * Structure used to hold the device-specific config parameters.
 * The setting of such parameters may not consistent with the
 * hardware feature of the device. It's used for software purpose.
 */
typedef struct nge_dev_spec_param {
        boolean_t       msi;            /* specifies msi support */
        boolean_t       msi_x;          /* specifies msi_x support */
        boolean_t       vlan;           /* specifies vlan support */
        boolean_t       advanced_pm;    /* advanced power management support */
        boolean_t       mac_addr_order; /* mac address order */
        boolean_t       tx_pause_frame; /* specifies tx pause frame support */
        boolean_t       rx_pause_frame; /* specifies rx pause frame support */
        boolean_t       jumbo;          /* jumbo frame support */
        boolean_t       tx_rx_64byte;   /* set the max tx/rx prd fetch size */
        boolean_t       rx_hw_checksum; /* specifies tx hw checksum feature */
        uint32_t        tx_hw_checksum; /* specifies rx hw checksum feature */
        uint32_t        desc_type;      /* specifies descriptor type */
        uint32_t        rx_desc_num;    /* specifies rx descriptor number */
        uint32_t        tx_desc_num;    /* specifies tx descriptor number */
        uint32_t        nge_split;      /* specifies the split number */
} nge_dev_spec_param_t;

typedef struct nge {
        /*
         * These fields are set by attach() and unchanged thereafter ...
         */
        dev_info_t              *devinfo;       /* device instance      */
        mac_handle_t            mh;             /* mac module handle    */
        chip_info_t             chipinfo;
        ddi_acc_handle_t        cfg_handle;     /* DDI I/O handle       */
        ddi_acc_handle_t        io_handle;      /* DDI I/O handle       */
        void                    *io_regs;       /* mapped registers     */

        ddi_periodic_t          periodic_id;    /* periodical callback  */
        uint32_t                factotum_flag;
        ddi_softint_handle_t    factotum_hdl;   /* factotum callback    */
        ddi_softint_handle_t    resched_hdl;    /* reschedule callback  */
        uint_t                  soft_pri;

        ddi_intr_handle_t       *htable;        /* for array of interrupts */
        int                     intr_type;      /* type of interrupt */
        int                     intr_actual_cnt; /* alloc intrs count */
        int                     intr_req_cnt;   /* request intrs count */
        uint_t                  intr_pri;       /* interrupt priority   */
        int                     intr_cap;       /* interrupt capabilities */

        uint32_t                progress;       /* attach tracking      */
        uint32_t                debug;          /* flag to debug function */

        char                    ifname[8];      /* "nge0" ... "nge999" */


        enum nge_mac_state      nge_mac_state;  /* definitions above    */
        enum nge_chip_state     nge_chip_state; /* definitions above    */
        boolean_t               promisc;
        boolean_t               record_promisc;
        boolean_t               suspended;

        int                     resched_needed;
        uint32_t                default_mtu;
        uint32_t                max_sdu;
        uint32_t                buf_size;
        uint32_t                rx_desc;
        uint32_t                tx_desc;
        uint32_t                rx_buf;
        uint32_t                nge_split;
        uint32_t                watchdog;
        uint32_t                lowmem_mode;


        /*
         * Runtime read-write data starts here ...
         * 1 Receive Rings
         * 1 Send Rings
         *
         * Note: they're not necessarily all used.
         */
        struct buff_ring        buff[1];
        struct recv_ring        recv[1];
        struct send_ring        send[1];


        kmutex_t                genlock[1];
        krwlock_t               rwlock[1];
        kmutex_t                softlock[1];
        uint32_t                intr_masks;
        boolean_t               poll;
        boolean_t               ch_intr_mode;
        boolean_t               intr_moderation;
        uint32_t                recv_count;
        uint32_t                quiet_time;
        uint32_t                busy_time;
        uint64_t                tpkts_last;
        uint32_t                tfint_threshold;
        uint32_t                sw_intr_intv;
        nge_mac_addr_t          cur_uni_addr;
        uint32_t                rx_datahwm;
        uint32_t                rx_prdlwm;
        uint32_t                rx_prdhwm;
        uint32_t                rx_def;
        uint32_t                desc_mode;

        mul_item                *pcur_mulist;
        nge_mac_addr_t          cur_mul_addr;
        nge_mac_addr_t          cur_mul_mask;

        nge_desc_attr_t         desc_attr;

        /*
         * Link state data (protected by genlock)
         */
        int32_t                 link_state;     /* See GLD #defines     */
        uint32_t                stall_cknum;    /* Stall check number */

        uint32_t                phy_xmii_addr;
        uint32_t                phy_id;
        uint32_t                phy_mode;
        const phys_ops_t        *physops;
        uint16_t                phy_gen_status;

        uint32_t                param_loop_mode;

        kstat_t                 *nge_kstats[NGE_KSTAT_COUNT];
        nge_statistics_t        statistics;

        nge_dev_spec_param_t    dev_spec_param;

        uint32_t                param_en_pause:1,
                                param_en_asym_pause:1,
                                param_en_1000hdx:1,
                                param_en_1000fdx:1,
                                param_en_100fdx:1,
                                param_en_100hdx:1,
                                param_en_10fdx:1,
                                param_en_10hdx:1,
                                param_adv_autoneg:1,
                                param_adv_pause:1,
                                param_adv_asym_pause:1,
                                param_adv_1000fdx:1,
                                param_adv_1000hdx:1,
                                param_adv_100fdx:1,
                                param_adv_100hdx:1,
                                param_adv_10fdx:1,
                                param_adv_10hdx:1,
                                param_lp_autoneg:1,
                                param_lp_pause:1,
                                param_lp_asym_pause:1,
                                param_lp_1000fdx:1,
                                param_lp_1000hdx:1,
                                param_lp_100fdx:1,
                                param_lp_100hdx:1,
                                param_lp_10fdx:1,
                                param_lp_10hdx:1,
                                param_link_up:1,
                                param_link_autoneg:1,
                                param_link_rx_pause:1,
                                param_link_tx_pause:1,
                                param_pad_to_32:2;
        uint64_t                param_link_speed;
        link_duplex_t           param_link_duplex;
        int                     param_txbcopy_threshold;
        int                     param_rxbcopy_threshold;
        int                     param_recv_max_packet;
        int                     param_poll_quiet_time;
        int                     param_poll_busy_time;
        int                     param_rx_intr_hwater;
        int                     param_rx_intr_lwater;
} nge_t;

extern const nge_ksindex_t nge_statistics[];

/*
 * Sync a DMA area described by a dma_area_t
 */
#define DMA_SYNC(area, flag)    ((void) ddi_dma_sync((area).dma_hdl,    \
                                    (area).offset, (area).alength, (flag)))

/*
 * Find the (kernel virtual) address of block of memory
 * described by a dma_area_t
 */
#define DMA_VPTR(area)          ((area).mem_va)

/*
 * Zero a block of memory described by a dma_area_t
 */
#define DMA_ZERO(area)          bzero(DMA_VPTR(area), (area).alength)

/*
 * Next/Prev value of a cyclic index
 */
#define NEXT(index, limit)      ((index) + 1 < (limit) ? (index) + 1 : 0)
#define PREV(index, limit)      (0 == (index) ? (limit - 1) : (index) - 1)

#define NEXT_INDEX(ndx, num, lim)\
        (((ndx) + (num) < (lim)) ? ((ndx) + (num)) : ((ndx) + (num) - (lim)))


/*
 * Property lookups
 */
#define NGE_PROP_EXISTS(d, n)   ddi_prop_exists(DDI_DEV_T_ANY, (d),     \
                                        DDI_PROP_DONTPASS, (n))
#define NGE_PROP_GET_INT(d, n)  ddi_prop_get_int(DDI_DEV_T_ANY, (d),    \
                                        DDI_PROP_DONTPASS, (n), -1)


/*
 * Debugging ...
 */
#ifdef  DEBUG
#define NGE_DEBUGGING           1
#else
#define NGE_DEBUGGING           0
#endif  /* DEBUG */

/*
 * Bit flags in the 'debug' word ...
 */
#define NGE_DBG_STOP            0x00000001      /* early debug_enter()  */
#define NGE_DBG_TRACE           0x00000002      /* general flow tracing */

#define NGE_DBG_MII             0x00000010      /* low-level MII access */
#define NGE_DBG_CHIP            0x00000020      /* low(ish)-level code  */

#define NGE_DBG_RECV            0x00000100      /* receive-side code    */
#define NGE_DBG_SEND            0x00000200      /* packet-send code     */

#define NGE_DBG_INIT            0x00100000      /* initialisation       */
#define NGE_DBG_NEMO            0x00200000      /* MAC layer entry points */
#define NGE_DBG_STATS           0x00400000      /* statistics           */

#define NGE_DBG_BADIOC          0x01000000      /* unknown ioctls       */

#define NGE_DBG_NDD             0x10000000      /* NDD operations       */



/*
 * 'Do-if-debugging' macro.  The parameter <command> should be one or more
 * C statements (but without the *final* semicolon), which will either be
 * compiled inline or completely ignored, depending on the NGE_DEBUGGING
 * compile-time flag.
 *
 * You should get a compile-time error (at least on a DEBUG build) if
 * your statement isn't actually a statement, rather than unexpected
 * run-time behaviour caused by unintended matching of if-then-elses etc.
 *
 * Note that the NGE_DDB() macro itself can only be used as a statement,
 * not an expression, and should always be followed by a semicolon.
 */
#if NGE_DEBUGGING
#define NGE_DDB(command)        do {                                    \
                                        { command; }                    \
                                        _NOTE(CONSTANTCONDITION)        \
                                } while (0)
#else   /* NGE_DEBUGGING */
#define NGE_DDB(command)
/*
 * Old way of debugging.  This is a poor way, as it leeaves empty
 * statements that cause lint to croak.
 * #define      NGE_DDB(command)        do {                            \
 *                                      { _NOTE(EMPTY); }               \
 *                                      _NOTE(CONSTANTCONDITION)        \
 *                              } while (0)
 */
#endif  /* NGE_DEBUGGING */

/*
 * 'Internal' macros used to construct the TRACE/DEBUG macros below.
 * These provide the primitive conditional-call capability required.
 * Note: the parameter <args> is a parenthesised list of the actual
 * printf-style arguments to be passed to the debug function ...
 */
#define NGE_XDB(b, w, f, args)  NGE_DDB(if ((b) & (w)) f args)
#define NGE_GDB(b, args)        NGE_XDB(b, nge_debug, (*nge_gdb()), args)
#define NGE_LDB(b, args)        NGE_XDB(b, ngep->debug, \
                                    (*nge_db(ngep)), args)
#define NGE_CDB(f, args)        NGE_XDB(NGE_DBG, ngep->debug, f, args)

/*
 * Conditional-print macros.
 *
 * Define NGE_DBG to be the relevant member of the set of NGE_DBG_* values
 * above before using the NGE_GDEBUG() or NGE_DEBUG() macros.  The 'G'
 * versions look at the Global debug flag word (nge_debug); the non-G
 * versions look in the per-instance data (ngep->debug) and so require a
 * variable called 'ngep' to be in scope (and initialised!) before use.
 *
 * You could redefine NGE_TRC too if you really need two different
 * flavours of debugging output in the same area of code, but I don't
 * really recommend it.
 *
 * Note: the parameter <args> is a parenthesised list of the actual
 * arguments to be passed to the debug function, usually a printf-style
 * format string and corresponding values to be formatted.
 */

#define NGE_TRC NGE_DBG_TRACE

#define NGE_GTRACE(args)        NGE_GDB(NGE_TRC, args)
#define NGE_GDEBUG(args)        NGE_GDB(NGE_DBG, args)
#define NGE_TRACE(args)         NGE_LDB(NGE_TRC, args)
#define NGE_DEBUG(args)         NGE_LDB(NGE_DBG, args)

/*
 * Debug-only action macros
 */


#define NGE_REPORT(args)        NGE_DDB(nge_log args)

boolean_t nge_atomic_decrease(uint64_t *count_p, uint64_t n);
void nge_atomic_increase(uint64_t *count_p, uint64_t n);

int nge_alloc_dma_mem(nge_t *ngep, size_t memsize,
    ddi_device_acc_attr_t *attr_p, uint_t dma_flags, dma_area_t *dma_p);
void nge_free_dma_mem(dma_area_t *dma_p);
int nge_restart(nge_t *ngep);
void nge_wake_factotum(nge_t *ngep);

uint8_t nge_reg_get8(nge_t *ngep, nge_regno_t regno);
void nge_reg_put8(nge_t *ngep, nge_regno_t regno, uint8_t data);
uint16_t nge_reg_get16(nge_t *ngep, nge_regno_t regno);
void nge_reg_put16(nge_t *ngep, nge_regno_t regno, uint16_t data);
uint32_t nge_reg_get32(nge_t *ngep, nge_regno_t regno);
void nge_reg_put32(nge_t *ngep, nge_regno_t regno, uint32_t data);
uint_t nge_chip_factotum(caddr_t args1, caddr_t args2);
void nge_chip_cfg_init(nge_t *ngep, chip_info_t *infop, boolean_t reset);
void nge_init_dev_spec_param(nge_t *ngep);
int nge_chip_stop(nge_t *ngep, boolean_t fault);
void nge_restore_mac_addr(nge_t *ngep);
int nge_chip_reset(nge_t *ngep);
int nge_chip_start(nge_t *ngep);
void nge_chip_sync(nge_t *ngep);

uint_t nge_chip_intr(caddr_t arg1, caddr_t arg2);
enum ioc_reply nge_chip_ioctl(nge_t *ngep, mblk_t *mp, struct iocblk *iocp);

void nge_phys_init(nge_t *ngep);
boolean_t nge_phy_reset(nge_t *ngep);
uint16_t nge_mii_get16(nge_t *ngep, nge_regno_t regno);
void nge_mii_put16(nge_t *ngep, nge_regno_t regno, uint16_t data);

void nge_recv_recycle(caddr_t arg);
void nge_receive(nge_t *ngep);

uint_t nge_reschedule(caddr_t args1, caddr_t args2);
mblk_t *nge_m_tx(void *arg, mblk_t *mp);

void nge_tx_recycle(nge_t *ngep, boolean_t is_intr);
void nge_tx_recycle_all(nge_t *ngep);

int nge_nd_init(nge_t *ngep);
void nge_nd_cleanup(nge_t *ngep);


void nge_init_kstats(nge_t *ngep, int instance);
void nge_fini_kstats(nge_t *ngep);
int nge_m_stat(void *arg, uint_t stat, uint64_t *val);

uint32_t nge_atomic_shl32(uint32_t *sp, uint_t count);

void nge_log(nge_t *ngep, const char *fmt, ...);
void nge_problem(nge_t *ngep, const char *fmt, ...);
void nge_error(nge_t *ngep, const char *fmt, ...);
void
nge_report(nge_t *ngep, uint8_t error_id);

void (*nge_db(nge_t *ngep))(const char *fmt, ...);
void (*nge_gdb(void))(const char *fmt, ...);
extern  uint32_t nge_debug;

/*
 * DESC MODE 2
 */

extern void nge_sum_rxd_fill(void *, const ddi_dma_cookie_t *, size_t);
extern uint32_t nge_sum_rxd_check(const void *, size_t *);

extern void nge_sum_txd_fill(void *, const ddi_dma_cookie_t *,
                                size_t, uint32_t, boolean_t, boolean_t);
extern uint32_t nge_sum_txd_check(const void *);

/*
 * DESC MODE 3
 */

extern void nge_hot_rxd_fill(void *, const ddi_dma_cookie_t *, size_t);
extern uint32_t nge_hot_rxd_check(const void *, size_t *);

extern void nge_hot_txd_fill(void *, const ddi_dma_cookie_t *,
                                size_t, uint32_t, boolean_t, boolean_t);
extern uint32_t nge_hot_txd_check(const void *);

#ifdef __cplusplus
}
#endif

#endif  /* _SYS_NGE_H */