/*
* 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 2007-2009 Myricom, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef MYRI10GE_VAR_H
#define MYRI10GE_VAR_H
#ifdef __cplusplus
extern "C" {
#endif
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/kmem.h>
#include <sys/ksynch.h>
#include <sys/stat.h>
#include <sys/modctl.h>
#include <sys/debug.h>
#include <sys/dlpi.h>
#include <sys/ethernet.h>
#include <sys/mac_provider.h>
#define MAC_CAPAB_POLL 0
#define MC_RESOURCES 0
#include <sys/mac_ether.h>
#ifndef MYRICOM_PRIV
#include <sys/vlan.h>
#endif
#include <sys/pci.h>
#include <sys/pcie.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/strsubr.h> /* for hw cksum stuff */
#include <sys/pattr.h> /* for hw cksum stuff */
#include <netinet/in.h> /* for hw cksum stuff */
#include <netinet/ip.h> /* for hw cksum stuff */
#include <netinet/ip6.h> /* for hw cksum stuff */
#include <netinet/tcp.h> /* for hw cksum stuff */
#include <netinet/udp.h> /* for hw cksum stuff */
#include <sys/strsun.h>
#include <inet/common.h>
#include <inet/mi.h>
#include <inet/nd.h>
#include <sys/zmod.h>
#include <sys/cpuvar.h>
#include <sys/proc.h>
#include <sys/callb.h>
#include "myri10ge_mcp.h"
#include "myri10ge_version.h"
#define MYRI10GE_FW_OFFSET 1024*1024
#define MYRI10GE_EEPROM_STRINGS_SIZE 256
#define MYRI10GE_HIGHPART_TO_U32(X) \
(sizeof (X) == 8) ? ((uint32_t)((uint64_t)(X) >> 32)) : (0)
#define MYRI10GE_LOWPART_TO_U32(X) ((uint32_t)(X))
#define MYRI10GE_DDI_REG_SET_32_BIT_MEMORY_SPACE 2
#define MYRI10GE_DDI_REG_SET_64_BIT_MEMORY_SPACE 3
/*
* Max descriptors a TSO send can use; worst case is every descriptor
* crosses a 2KB boundary, as do the headers
*/
#define MYRI10GE_MAX_SEND_DESC_TSO (2 + (65536 / 2048) * 2)
#ifdef MYRICOM_PRIV
#define VLAN_TAGSZ 4
#endif
#if defined DDI_INTR_IS_MSI_OR_MSIX
#define MYRI10GE_USE_MSI 1
#else
#define MYRI10GE_USE_MSI 0
#endif
struct myri10ge_dma_stuff {
ddi_dma_handle_t handle;
ddi_acc_handle_t acc_handle;
uint32_t low;
uint32_t high;
};
typedef struct myri10ge_mblkq {
struct myri10ge_priv *mgp;
kmutex_t lock;
mblk_t *head;
mblk_t *tail;
unsigned long cnt;
} myri10ge_mblkq_t;
typedef struct {
mcp_slot_t *entry;
struct myri10ge_dma_stuff dma;
int cnt;
int idx;
} myri10ge_rx_done_t;
typedef struct
{
uint32_t data0;
uint32_t data1;
uint32_t data2;
} myri10ge_cmd_t;
struct myri10ge_pci_saved_state {
uint32_t base[16];
uint32_t msi_addr_low;
uint32_t msi_addr_high;
uint16_t msi_data_32;
uint16_t msi_data_64;
uint16_t msi_ctrl;
};
struct myri10ge_jpool_entry;
struct myri10ge_jpool_entry {
struct myri10ge_jpool_entry *next;
ddi_dma_handle_t dma_handle;
ddi_acc_handle_t acc_handle;
caddr_t buf;
struct myri10ge_slice_state *ss;
mcp_dma_addr_t dma; /* Kept in network byte order */
frtn_t free_func;
};
#define MYRI10GE_CPU_CACHE_SZ 64
struct myri10ge_per_cpu_jpool {
struct myri10ge_jpool_entry *head;
uint8_t _pad[MYRI10GE_CPU_CACHE_SZ - sizeof (void *)];
};
#define MYRI10GE_MAX_CPUS 64
#define MYRI10GE_MAX_CPU_MASK (64 - 1)
struct myri10ge_jpool_stuff {
struct myri10ge_jpool_entry *head;
struct myri10ge_per_cpu_jpool cpu[MYRI10GE_MAX_CPUS];
kmutex_t mtx;
int num_alloc;
int low_water;
};
struct myri10ge_tx_ring_stats
{
uint64_t multixmt;
uint64_t brdcstxmt;
uint64_t opackets;
uint64_t obytes;
};
struct myri10ge_rx_ring_stats
{
uint64_t multircv;
uint64_t brdcstrcv;
uint64_t ipackets;
uint64_t ibytes;
};
struct myri10ge_tx_ring_entry_stats
{
uint32_t obytes;
uint16_t opackets;
uint8_t brdcstxmt;
uint8_t multixmt;
};
struct myri10ge_tx_pkt_stats {
union {
uint64_t all;
struct myri10ge_tx_ring_entry_stats s;
} un;
};
#define ostat stat.un.s
struct myri10ge_tx_dma_handle {
struct myri10ge_tx_dma_handle *next;
ddi_dma_handle_t h;
};
struct myri10ge_tx_dma_handle_head {
struct myri10ge_tx_dma_handle *head;
struct myri10ge_tx_dma_handle *tail;
};
struct myri10ge_rx_buffer_state {
caddr_t ptr;
struct myri10ge_jpool_entry *j;
};
struct myri10ge_tx_buffer_state {
mblk_t *m;
struct myri10ge_tx_dma_handle *handle;
struct myri10ge_tx_pkt_stats stat;
};
struct myri10ge_nic_stat {
struct kstat_named dma_force_physical;
struct kstat_named dma_read_bw_MBs;
struct kstat_named dma_write_bw_MBs;
struct kstat_named dma_read_write_bw_MBs;
struct kstat_named lanes;
struct kstat_named dropped_bad_crc32;
struct kstat_named dropped_bad_phy;
struct kstat_named dropped_link_error_or_filtered;
struct kstat_named dropped_link_overflow;
struct kstat_named dropped_multicast_filtered;
struct kstat_named dropped_no_big_buffer;
struct kstat_named dropped_no_small_buffer;
struct kstat_named dropped_overrun;
struct kstat_named dropped_pause;
struct kstat_named dropped_runt;
struct kstat_named dropped_unicast_filtered;
struct kstat_named link_changes;
struct kstat_named link_up;
};
struct myri10ge_slice_stat {
struct kstat_named lro_bad_csum;
struct kstat_named lro_flushed;
struct kstat_named lro_queued;
struct kstat_named rx_big;
struct kstat_named rx_bigbuf_firmware;
struct kstat_named rx_bigbuf_pool;
struct kstat_named rx_bigbuf_smalls;
struct kstat_named rx_copy;
struct kstat_named rx_small;
struct kstat_named rx_big_nobuf;
struct kstat_named rx_small_nobuf;
struct kstat_named tx_activate;
struct kstat_named tx_done;
struct kstat_named tx_handles_alloced;
struct kstat_named tx_req;
struct kstat_named xmit_err;
struct kstat_named xmit_lowbuf;
struct kstat_named xmit_lsobadflags;
struct kstat_named xmit_pullup;
struct kstat_named xmit_pullup_first;
struct kstat_named xmit_sched;
struct kstat_named xmit_stall;
struct kstat_named xmit_stall_early;
struct kstat_named xmit_stall_late;
struct kstat_named xmit_zero_len;
};
struct myri10ge_info {
struct kstat_named driver_version;
struct kstat_named firmware_version;
struct kstat_named firmware_name;
struct kstat_named interrupt_type;
struct kstat_named product_code;
struct kstat_named serial_number;
};
#define MYRI10GE_NIC_STAT_INC(field) \
(((struct myri10ge_nic_stat *)mgp->ksp_stat->ks_data)->field.value.ul)++
#define MYRI10GE_SLICE_STAT_INC(field) \
(((struct myri10ge_slice_stat *)ss->ksp_stat->ks_data)->field.value.ul)++
#define MYRI10GE_SLICE_STAT_ADD(field, val) \
(((struct myri10ge_slice_stat *)ss->ksp_stat->ks_data)->field.value.ul) += val
#define MYRI10GE_SLICE_STAT_DEC(field) \
(((struct myri10ge_slice_stat *)ss->ksp_stat->ks_data)->field.value.ul)--
#define MYRI10GE_ATOMIC_SLICE_STAT_INC(field) \
atomic_inc_ulong(&(((struct myri10ge_slice_stat *) \
ss->ksp_stat->ks_data)->field.value.ul))
#define MYRI10GE_ATOMIC_SLICE_STAT_DEC(field) \
atomic_dec_ulong(&(((struct myri10ge_slice_stat *) \
ss->ksp_stat->ks_data)->field.value.ul))
#define MYRI10GE_SLICE_STAT(field) \
(((struct myri10ge_slice_stat *)ss->ksp_stat->ks_data)->field.value.ul)
struct myri10ge_tx_copybuf
{
caddr_t va;
int len;
struct myri10ge_dma_stuff dma;
};
typedef struct
{
mcp_kreq_ether_recv_t *lanai; /* lanai ptr for recv ring */
mcp_kreq_ether_recv_t *shadow; /* host shadow of recv ring */
struct myri10ge_rx_buffer_state *info;
int cnt;
int alloc_fail;
int mask; /* number of rx slots -1 */
boolean_t polling;
} myri10ge_rx_ring_t;
typedef struct
{
mcp_kreq_ether_send_t *lanai; /* lanai ptr for sendq */
char *go; /* doorbell to poll sendq */
char *stop; /* doorbell to !poll sendq */
struct myri10ge_tx_buffer_state *info;
struct myri10ge_tx_copybuf *cp;
int req; /* transmits submitted */
int mask; /* number of transmit slots -1 */
int done; /* transmits completed */
int pkt_done; /* packets completed */
int active;
uint32_t stall;
uint32_t stall_early;
uint32_t stall_late;
int sched;
kmutex_t lock;
struct myri10ge_tx_ring_stats stats;
int watchdog_req;
int watchdog_done;
unsigned long activate;
kmutex_t handle_lock;
struct myri10ge_tx_dma_handle *free_tx_handles;
mac_ring_handle_t rh;
} myri10ge_tx_ring_t;
struct lro_entry;
struct lro_entry
{
struct lro_entry *next;
mblk_t *m_head;
mblk_t *m_tail;
int timestamp;
struct ip *ip;
uint32_t tsval;
uint32_t tsecr;
uint32_t source_ip;
uint32_t dest_ip;
uint32_t next_seq;
uint32_t ack_seq;
uint32_t len;
uint32_t data_csum;
uint16_t window;
uint16_t source_port;
uint16_t dest_port;
uint16_t append_cnt;
uint16_t mss;
uint8_t flags;
};
struct myri10ge_mblk_list
{
mblk_t *head;
mblk_t **tail;
int cnt;
};
struct myri10ge_priv;
struct myri10ge_slice_state {
struct myri10ge_priv *mgp;
myri10ge_tx_ring_t tx; /* transmit ring */
myri10ge_rx_ring_t rx_small;
myri10ge_rx_ring_t rx_big;
myri10ge_rx_done_t rx_done;
struct myri10ge_jpool_stuff jpool;
struct myri10ge_rx_ring_stats rx_stats;
volatile uint32_t *irq_claim;
mcp_irq_data_t *fw_stats;
struct lro_entry *lro_active;
struct lro_entry *lro_free;
struct myri10ge_dma_stuff fw_stats_dma;
int jbufs_for_smalls;
struct myri10ge_jpool_entry *small_jpool;
int j_rx_cnt;
mac_resource_handle_t mrh;
kstat_t *ksp_stat;
mac_ring_handle_t rx_rh;
kmutex_t rx_lock;
kmutex_t poll_lock;
uint64_t rx_gen_num;
boolean_t rx_polling;
int rx_token;
int watchdog_rx_copy;
};
struct myri10ge_priv {
struct myri10ge_slice_state *ss;
int max_intr_slots;
int num_slices;
dev_info_t *dip;
mac_handle_t mh;
ddi_acc_handle_t io_handle;
int tx_boundary;
int watchdog_rx_pause;
kstat_t *ksp_stat;
kstat_t *ksp_info;
int running; /* running? */
int csum_flag; /* rx_csums? */
uint8_t mac_addr[6]; /* eeprom mac address */
volatile uint8_t *sram;
int sram_size;
unsigned long board_span;
unsigned long iomem_base;
volatile uint32_t *irq_deassert;
char *mac_addr_string;
mcp_cmd_response_t *cmd;
struct myri10ge_dma_stuff cmd_dma;
int msi_enabled;
int link_state;
int rdma_tags_available;
int intr_coal_delay;
volatile uint32_t *intr_coal_delay_ptr;
kmutex_t cmd_lock;
kmutex_t intrlock;
int down_cnt;
int watchdog_resets;
unsigned char *eth_z8e;
unsigned int eth_z8e_length;
ddi_iblock_cookie_t icookie;
ddi_intr_handle_t *htable;
int intr_size;
int intr_cnt;
int intr_cap;
unsigned int intr_pri;
int ddi_intr_type;
int pause;
timeout_id_t timer_id;
clock_t timer_ticks;
int vso;
uint32_t mcp_index;
char fw_version[128];
char name[32];
char *fw_name;
char *intr_type;
char eeprom_strings[MYRI10GE_EEPROM_STRINGS_SIZE];
char *sn_str;
char *pc_str;
uint32_t read_dma;
uint32_t write_dma;
uint32_t read_write_dma;
uint32_t pcie_link_width;
int max_read_request_4k;
caddr_t nd_head;
struct myri10ge_priv *next;
uint_t refcnt;
int reg_set;
int features;
struct myri10ge_pci_saved_state pci_saved_state;
uint32_t *toeplitz_hash_table;
uint32_t rss_key[8];
ddi_acc_handle_t cfg_hdl;
int macaddr_cnt;
};
/* features bitmask */
#define MYRI10GE_TSO 1
#if defined(__GNUC__)
#define likely(x) __builtin_expect((x), 1)
#define unlikely(x) __builtin_expect((x), 0)
#else
#define likely(x) (x)
#define unlikely(x) (x)
#endif /* defined(__GNUC__) */
#define mb membar_producer
struct myri10ge_priv *myri10ge_get_instance(uint_t unit);
void myri10ge_put_instance(struct myri10ge_priv *);
int myri10ge_send_cmd(struct myri10ge_priv *mgp, uint32_t cmd,
myri10ge_cmd_t *data);
caddr_t myri10ge_dma_alloc(dev_info_t *dip, size_t len,
ddi_dma_attr_t *attr, ddi_device_acc_attr_t *accattr,
uint_t alloc_flags, int bind_flags, struct myri10ge_dma_stuff *dma,
int warn, int (*waitfp)(caddr_t));
void myri10ge_dma_free(struct myri10ge_dma_stuff *dma);
void myri10ge_lro_flush(struct myri10ge_slice_state *ss,
struct lro_entry *lro, struct myri10ge_mblk_list *mbl);
int myri10ge_lro_rx(struct myri10ge_slice_state *ss, mblk_t *m_head,
uint32_t csum, struct myri10ge_mblk_list *mbl);
void myri10ge_mbl_append(struct myri10ge_slice_state *ss,
struct myri10ge_mblk_list *mbl, mblk_t *mp);
uint16_t myri10ge_csum_generic(uint16_t *raw, int len);
extern int myri10ge_lro_max_aggr;
extern int myri10ge_mtu;
#ifndef ETHERNET_HEADER_SIZE
#define ETHERNET_HEADER_SIZE 14
#endif
#define MYRI10GE_TOEPLITZ_HASH (MXGEFW_RSS_HASH_TYPE_TCP_IPV4|\
MXGEFW_RSS_HASH_TYPE_IPV4)
#define MYRI10GE_POLL_NULL INT_MAX
/*
* This file uses MyriGE driver indentation.
*
* Local Variables:
* c-file-style:"sun"
* tab-width:8
* End:
*/
#ifdef __cplusplus
}
#endif
#endif /* MYRI10GE_VAR_H */