/**************************************************************************
 *
 * Copyright (c) 2000-2002 Alacritech, Inc.  All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY ALACRITECH, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ALACRITECH, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation
 * are those of the authors and should not be interpreted as representing
 * official policies, either expressed or implied, of Alacritech, Inc.
 *
 **************************************************************************/

/*
 * FILENAME: slic.h
 *
 * This is the base set of header definitions for the SLICOSS driver.
 */
#ifndef __SLIC_DRIVER_H__
#define __SLIC_DRIVER_H__

/* firmware stuff */
#define OASIS_UCODE_VERS_STRING	"1.2"
#define OASIS_UCODE_VERS_DATE  	"2006/03/27 15:10:37"
#define OASIS_UCODE_HOSTIF_ID  	3

#define MOJAVE_UCODE_VERS_STRING	"1.2"
#define MOJAVE_UCODE_VERS_DATE  	"2006/03/27 15:12:22"
#define MOJAVE_UCODE_HOSTIF_ID  	3

#define GB_RCVUCODE_VERS_STRING	"1.2"
#define GB_RCVUCODE_VERS_DATE  	"2006/03/27 15:12:15"
static u32 OasisRcvUCodeLen = 512;
static u32 GBRcvUCodeLen = 512;
#define SECTION_SIZE 65536

struct slic_spinlock {
	spinlock_t	lock;
	unsigned long	flags;
};

#define SLIC_RSPQ_PAGES_GB        10
#define SLIC_RSPQ_BUFSINPAGE      (PAGE_SIZE / SLIC_RSPBUF_SIZE)

struct slic_rspqueue {
    u32             offset;
    u32             pageindex;
    u32             num_pages;
    struct slic_rspbuf *rspbuf;
    u32 *vaddr[SLIC_RSPQ_PAGES_GB];
    dma_addr_t          paddr[SLIC_RSPQ_PAGES_GB];
};

#define SLIC_RCVQ_EXPANSION         1
#define SLIC_RCVQ_ENTRIES           (256 * SLIC_RCVQ_EXPANSION)
#define SLIC_RCVQ_MINENTRIES        (SLIC_RCVQ_ENTRIES / 2)
#define SLIC_RCVQ_MAX_PROCESS_ISR   ((SLIC_RCVQ_ENTRIES * 4))
#define SLIC_RCVQ_RCVBUFSIZE        2048
#define SLIC_RCVQ_FILLENTRIES       (16 * SLIC_RCVQ_EXPANSION)
#define SLIC_RCVQ_FILLTHRESH        (SLIC_RCVQ_ENTRIES - SLIC_RCVQ_FILLENTRIES)

struct slic_rcvqueue {
    struct sk_buff    *head;
    struct sk_buff    *tail;
    u32            count;
    u32            size;
    u32            errors;
};

struct slic_rcvbuf_info {
    u32     id;
    u32     starttime;
    u32     stoptime;
    u32     slicworld;
    u32     lasttime;
    u32     lastid;
};
/*
 SLIC Handle structure.  Used to restrict handle values to
 32 bits by using an index rather than an address.
 Simplifies ucode in 64-bit systems
*/
struct slic_handle_word {
	union {
		struct {
			ushort      index;
			ushort      bottombits; /* to denote num bufs to card */
		}  parts;
		u32         whole;
	}  handle;
};

struct slic_handle {
    struct slic_handle_word  token;  /* token passed between host and card*/
    ushort                      type;
    void *address;    /* actual address of the object*/
    ushort                      offset;
    struct slic_handle       *other_handle;
    struct slic_handle       *next;
};

#define SLIC_HANDLE_FREE        0x0000
#define SLIC_HANDLE_DATA        0x0001
#define SLIC_HANDLE_CMD         0x0002
#define SLIC_HANDLE_CONTEXT     0x0003
#define SLIC_HANDLE_TEAM        0x0004

#define handle_index        handle.parts.index
#define handle_bottom       handle.parts.bottombits
#define handle_token        handle.whole

#define SLIC_HOSTCMD_SIZE    512

struct slic_hostcmd {
    struct slic_host64_cmd  cmd64;
    u32                    type;
    struct sk_buff            *skb;
    u32                    paddrl;
    u32                    paddrh;
    u32                    busy;
    u32                    cmdsize;
    ushort                     numbufs;
    struct slic_handle    *pslic_handle;/* handle associated with command */
    struct slic_hostcmd    *next;
    struct slic_hostcmd    *next_all;
};

#define SLIC_CMDQ_CMDSINPAGE    (PAGE_SIZE / SLIC_HOSTCMD_SIZE)
#define SLIC_CMD_DUMB            3
#define SLIC_CMDQ_INITCMDS       256
#define SLIC_CMDQ_MAXCMDS        256
#define SLIC_CMDQ_MAXOUTSTAND    SLIC_CMDQ_MAXCMDS
#define SLIC_CMDQ_MAXPAGES       (SLIC_CMDQ_MAXCMDS / SLIC_CMDQ_CMDSINPAGE)
#define SLIC_CMDQ_INITPAGES      (SLIC_CMDQ_INITCMDS / SLIC_CMDQ_CMDSINPAGE)

struct slic_cmdqmem {
	int pagecnt;
	u32 *pages[SLIC_CMDQ_MAXPAGES];
	dma_addr_t dma_pages[SLIC_CMDQ_MAXPAGES];
};

struct slic_cmdqueue {
	struct slic_hostcmd *head;
	struct slic_hostcmd *tail;
	int count;
	struct slic_spinlock lock;
};

#define SLIC_MAX_CARDS              32
#define SLIC_MAX_PORTS              4        /* Max # of ports per card   */


struct mcast_address {
	unsigned char address[6];
	struct mcast_address *next;
};

#define CARD_DOWN        0x00000000
#define CARD_UP          0x00000001
#define CARD_FAIL        0x00000002
#define CARD_DIAG        0x00000003
#define CARD_SLEEP       0x00000004

#define ADAPT_DOWN             0x00
#define ADAPT_UP               0x01
#define ADAPT_FAIL             0x02
#define ADAPT_RESET            0x03
#define ADAPT_SLEEP            0x04

#define ADAPT_FLAGS_BOOTTIME            0x0001
#define ADAPT_FLAGS_IS64BIT             0x0002
#define ADAPT_FLAGS_PENDINGLINKDOWN     0x0004
#define ADAPT_FLAGS_FIBERMEDIA          0x0008
#define ADAPT_FLAGS_LOCKS_ALLOCED       0x0010
#define ADAPT_FLAGS_INT_REGISTERED      0x0020
#define ADAPT_FLAGS_LOAD_TIMER_SET      0x0040
#define ADAPT_FLAGS_STATS_TIMER_SET     0x0080
#define ADAPT_FLAGS_RESET_TIMER_SET     0x0100

#define LINK_DOWN              0x00
#define LINK_CONFIG            0x01
#define LINK_UP                0x02

#define LINK_10MB              0x00
#define LINK_100MB             0x01
#define LINK_AUTOSPEED         0x02
#define LINK_1000MB            0x03
#define LINK_10000MB           0x04

#define LINK_HALFD             0x00
#define LINK_FULLD             0x01
#define LINK_AUTOD             0x02

#define MAC_DIRECTED     0x00000001
#define MAC_BCAST        0x00000002
#define MAC_MCAST        0x00000004
#define MAC_PROMISC      0x00000008
#define MAC_LOOPBACK     0x00000010
#define MAC_ALLMCAST     0x00000020

#define SLIC_DUPLEX(x)    ((x == LINK_FULLD) ? "FDX" : "HDX")
#define SLIC_SPEED(x)     ((x == LINK_100MB) ? "100Mb" : ((x == LINK_1000MB) ?\
				"1000Mb" : " 10Mb"))
#define SLIC_LINKSTATE(x) ((x == LINK_DOWN) ? "Down" : "Up  ")
#define SLIC_ADAPTER_STATE(x) ((x == ADAPT_UP) ? "UP" : "Down")
#define SLIC_CARD_STATE(x)    ((x == CARD_UP) ? "UP" : "Down")

struct slic_iface_stats {
    /*
     * Stats
     */
    u64        xmt_bytes;
    u64        xmt_ucast;
    u64        xmt_mcast;
    u64        xmt_bcast;
    u64        xmt_errors;
    u64        xmt_discards;
    u64        xmit_collisions;
    u64        xmit_excess_xmit_collisions;
    u64        rcv_bytes;
    u64        rcv_ucast;
    u64        rcv_mcast;
    u64        rcv_bcast;
    u64        rcv_errors;
    u64        rcv_discards;
};

struct sliccp_stats {
    u64        xmit_tcp_segs;
    u64        xmit_tcp_bytes;
    u64        rcv_tcp_segs;
    u64        rcv_tcp_bytes;
};

struct slicnet_stats {
    struct sliccp_stats        tcp;
    struct slic_iface_stats      iface;
};

#define SLIC_LOADTIMER_PERIOD     1
#define SLIC_INTAGG_DEFAULT       200
#define SLIC_LOAD_0               0
#define SLIC_INTAGG_0             0
#define SLIC_LOAD_1               8000
#define SLIC_LOAD_2               10000
#define SLIC_LOAD_3               12000
#define SLIC_LOAD_4               14000
#define SLIC_LOAD_5               16000
#define SLIC_INTAGG_1             50
#define SLIC_INTAGG_2             100
#define SLIC_INTAGG_3             150
#define SLIC_INTAGG_4             200
#define SLIC_INTAGG_5             250
#define SLIC_LOAD_1GB             3000
#define SLIC_LOAD_2GB             6000
#define SLIC_LOAD_3GB             12000
#define SLIC_LOAD_4GB             24000
#define SLIC_LOAD_5GB             48000
#define SLIC_INTAGG_1GB           50
#define SLIC_INTAGG_2GB           75
#define SLIC_INTAGG_3GB           100
#define SLIC_INTAGG_4GB           100
#define SLIC_INTAGG_5GB           100

struct ether_header {
    unsigned char    ether_dhost[6];
    unsigned char    ether_shost[6];
    ushort   ether_type;
};

struct sliccard {
    uint              busnumber;
    uint              slotnumber;
    uint              state;
    uint              cardnum;
    uint              card_size;
    uint              adapters_activated;
    uint              adapters_allocated;
    uint              adapters_sleeping;
    uint              gennumber;
    u32           events;
    u32           loadlevel_current;
    u32           load;
    uint              reset_in_progress;
    u32           pingstatus;
    u32           bad_pingstatus;
    struct timer_list loadtimer;
    u32           loadtimerset;
    uint              config_set;
    struct slic_config  config;
    struct dentry      *debugfs_dir;
    struct dentry      *debugfs_cardinfo;
    struct adapter  *master;
    struct adapter  *adapter[SLIC_MAX_PORTS];
    struct sliccard *next;
    u32             error_interrupts;
    u32             error_rmiss_interrupts;
    u32             rcv_interrupts;
    u32             xmit_interrupts;
    u32             num_isrs;
    u32             false_interrupts;
    u32             max_isr_rcvs;
    u32             max_isr_xmits;
    u32             rcv_interrupt_yields;
    u32             tx_packets;
    u32             debug_ix;
    ushort              reg_type[32];
    ushort              reg_offset[32];
    u32             reg_value[32];
    u32             reg_valueh[32];
};

#define NUM_CFG_SPACES      2
#define NUM_CFG_REGS        64
#define NUM_CFG_REG_ULONGS  (NUM_CFG_REGS / sizeof(u32))

struct physcard {
    struct adapter  *adapter[SLIC_MAX_PORTS];
    struct physcard *next;
    uint                adapters_allocd;

 /*  the following is not currently needed
    u32               bridge_busnum;
    u32               bridge_cfg[NUM_CFG_SPACES][NUM_CFG_REG_ULONGS];
 */
};

struct base_driver {
    struct slic_spinlock driver_lock;
    u32              num_slic_cards;
    u32              num_slic_ports;
    u32              num_slic_ports_active;
    u32              dynamic_intagg;
    struct sliccard  *slic_card;
    struct physcard  *phys_card;
    uint                 cardnuminuse[SLIC_MAX_CARDS];
};

struct slic_shmem {
    volatile u32          isr;
    volatile u32          linkstatus;
    volatile struct slic_stats     inicstats;
};

struct slic_reg_params {
    u32       linkspeed;
    u32       linkduplex;
    u32       fail_on_bad_eeprom;
};

struct slic_upr {
    uint               adapter;
    u32            upr_request;
    u32            upr_data;
    u32            upr_data_h;
    u32            upr_buffer;
    u32            upr_buffer_h;
    struct slic_upr *next;
};

struct slic_ifevents {
    uint        oflow802;
    uint        uflow802;
    uint        Tprtoflow;
    uint        rcvearly;
    uint        Bufov;
    uint        Carre;
    uint        Longe;
    uint        Invp;
    uint        Crc;
    uint        Drbl;
    uint        Code;
    uint        IpHlen;
    uint        IpLen;
    uint        IpCsum;
    uint        TpCsum;
    uint        TpHlen;
};

struct adapter {
    void *ifp;
    struct sliccard *card;
    uint                port;
    struct physcard *physcard;
    uint                physport;
    uint                cardindex;
    uint                card_size;
    uint                chipid;
    struct net_device  *netdev;
    struct net_device  *next_netdevice;
    struct slic_spinlock     adapter_lock;
    struct slic_spinlock     reset_lock;
    struct pci_dev     *pcidev;
    uint                busnumber;
    uint                slotnumber;
    uint                functionnumber;
    ushort              vendid;
    ushort              devid;
    ushort              subsysid;
    u32             irq;
    void __iomem *memorybase;
    u32             memorylength;
    u32             drambase;
    u32             dramlength;
    uint                queues_initialized;
    uint                allocated;
    uint                activated;
    u32             intrregistered;
    uint                isp_initialized;
    uint                gennumber;
    u32             curaddrupper;
    struct slic_shmem      *pshmem;
    dma_addr_t          phys_shmem;
    u32             isrcopy;
    __iomem struct slic_regs       *slic_regs;
    unsigned char               state;
    unsigned char               linkstate;
    unsigned char               linkspeed;
    unsigned char               linkduplex;
    uint                flags;
    unsigned char               macaddr[6];
    unsigned char               currmacaddr[6];
    u32             macopts;
    ushort              devflags_prev;
    u64             mcastmask;
    struct mcast_address   *mcastaddrs;
    struct slic_upr   *upr_list;
    uint                upr_busy;
    struct timer_list   pingtimer;
    u32             pingtimerset;
    struct timer_list   loadtimer;
    u32             loadtimerset;
    struct dentry      *debugfs_entry;
    struct slic_spinlock     upr_lock;
    struct slic_spinlock     bit64reglock;
    struct slic_rspqueue     rspqueue;
    struct slic_rcvqueue     rcvqueue;
    struct slic_cmdqueue     cmdq_free;
    struct slic_cmdqueue     cmdq_done;
    struct slic_cmdqueue     cmdq_all;
    struct slic_cmdqmem      cmdqmem;
    /*
     *  SLIC Handles
    */
    struct slic_handle slic_handles[SLIC_CMDQ_MAXCMDS+1]; /* Object handles*/
    struct slic_handle *pfree_slic_handles;          /* Free object handles*/
    struct slic_spinlock     handle_lock;           /* Object handle list lock*/
    ushort              slic_handle_ix;

    u32             xmitq_full;
    u32             all_reg_writes;
    u32             icr_reg_writes;
    u32             isr_reg_writes;
    u32             error_interrupts;
    u32             error_rmiss_interrupts;
    u32             rx_errors;
    u32             rcv_drops;
    u32             rcv_interrupts;
    u32             xmit_interrupts;
    u32             linkevent_interrupts;
    u32             upr_interrupts;
    u32             num_isrs;
    u32             false_interrupts;
    u32             tx_packets;
    u32             xmit_completes;
    u32             tx_drops;
    u32             rcv_broadcasts;
    u32             rcv_multicasts;
    u32             rcv_unicasts;
    u32             max_isr_rcvs;
    u32             max_isr_xmits;
    u32             rcv_interrupt_yields;
    u32             intagg_period;
    struct inicpm_state    *inicpm_info;
    void *pinicpm_info;
    struct slic_reg_params   reg_params;
    struct slic_ifevents  if_events;
    struct slic_stats        inicstats_prev;
    struct slicnet_stats     slic_stats;
};


#define UPDATE_STATS(largestat, newstat, oldstat)                        \
{                                                                        \
    if ((newstat) < (oldstat))                                           \
	(largestat) += ((newstat) + (0xFFFFFFFF - oldstat + 1));         \
    else                                                                 \
	(largestat) += ((newstat) - (oldstat));                          \
}

#define UPDATE_STATS_GB(largestat, newstat, oldstat)                     \
{                                                                        \
    (largestat) += ((newstat) - (oldstat));                              \
}

#if BITS_PER_LONG == 64
#define   SLIC_GET_ADDR_LOW(_addr)  (u32)((u64)(_addr) & \
	0x00000000FFFFFFFF)
#define   SLIC_GET_ADDR_HIGH(_addr)  (u32)(((u64)(_addr) >> 32) & \
	0x00000000FFFFFFFF)
#elif BITS_PER_LONG == 32
#define   SLIC_GET_ADDR_LOW(_addr)   (u32)(_addr)
#define   SLIC_GET_ADDR_HIGH(_addr)  (u32)0
#else
#error BITS_PER_LONG must be 32 or 64
#endif

#define FLUSH		true
#define DONT_FLUSH	false

#define SIOCSLICDUMPCARD         (SIOCDEVPRIVATE+9)
#define SIOCSLICSETINTAGG        (SIOCDEVPRIVATE+10)
#define SIOCSLICTRACEDUMP        (SIOCDEVPRIVATE+11)

#endif /*  __SLIC_DRIVER_H__ */