[mirror_ubuntu-artful-kernel.git] / drivers / infiniband / ulp / ipoib / ipoib.h

/*
 * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
 * Copyright (c) 2004 Voltaire, Inc. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - 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.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * $Id: ipoib.h 1358 2004-12-17 22:00:11Z roland $
 */

#ifndef _IPOIB_H
#define _IPOIB_H

#include <linux/list.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/workqueue.h>
#include <linux/kref.h>
#include <linux/if_infiniband.h>
#include <linux/mutex.h>

#include <net/neighbour.h>

#include <asm/atomic.h>

#include <rdma/ib_verbs.h>
#include <rdma/ib_pack.h>
#include <rdma/ib_sa.h>

/* constants */

enum {
	IPOIB_PACKET_SIZE         = 2048,
	IPOIB_BUF_SIZE 		  = IPOIB_PACKET_SIZE + IB_GRH_BYTES,

	IPOIB_ENCAP_LEN 	  = 4,

	IPOIB_CM_MTU              = 0x10000 - 0x10, /* padding to align header to 16 */
	IPOIB_CM_BUF_SIZE         = IPOIB_CM_MTU  + IPOIB_ENCAP_LEN,
	IPOIB_CM_HEAD_SIZE 	  = IPOIB_CM_BUF_SIZE % PAGE_SIZE,
	IPOIB_CM_RX_SG            = ALIGN(IPOIB_CM_BUF_SIZE, PAGE_SIZE) / PAGE_SIZE,
	IPOIB_RX_RING_SIZE 	  = 128,
	IPOIB_TX_RING_SIZE 	  = 64,
	IPOIB_MAX_QUEUE_SIZE	  = 8192,
	IPOIB_MIN_QUEUE_SIZE	  = 2,

	IPOIB_NUM_WC 		  = 4,

	IPOIB_MAX_PATH_REC_QUEUE  = 3,
	IPOIB_MAX_MCAST_QUEUE     = 3,

	IPOIB_FLAG_OPER_UP 	  = 0,
	IPOIB_FLAG_INITIALIZED    = 1,
	IPOIB_FLAG_ADMIN_UP 	  = 2,
	IPOIB_PKEY_ASSIGNED 	  = 3,
	IPOIB_PKEY_STOP 	  = 4,
	IPOIB_FLAG_SUBINTERFACE   = 5,
	IPOIB_MCAST_RUN 	  = 6,
	IPOIB_STOP_REAPER         = 7,
	IPOIB_MCAST_STARTED       = 8,
	IPOIB_FLAG_NETIF_STOPPED  = 9,
	IPOIB_FLAG_ADMIN_CM 	  = 10,

	IPOIB_MAX_BACKOFF_SECONDS = 16,

	IPOIB_MCAST_FLAG_FOUND 	  = 0,	/* used in set_multicast_list */
	IPOIB_MCAST_FLAG_SENDONLY = 1,
	IPOIB_MCAST_FLAG_BUSY 	  = 2,	/* joining or already joined */
	IPOIB_MCAST_FLAG_ATTACHED = 3,
};

#define	IPOIB_OP_RECV   (1ul << 31)
#ifdef CONFIG_INFINIBAND_IPOIB_CM
#define	IPOIB_CM_OP_SRQ (1ul << 30)
#else
#define	IPOIB_CM_OP_SRQ (0)
#endif

/* structs */

struct ipoib_header {
	__be16	proto;
	u16	reserved;
};

struct ipoib_pseudoheader {
	u8  hwaddr[INFINIBAND_ALEN];
};

struct ipoib_mcast;

struct ipoib_rx_buf {
	struct sk_buff *skb;
	u64		mapping;
};

struct ipoib_tx_buf {
	struct sk_buff *skb;
	u64		mapping;
};

struct ib_cm_id;

struct ipoib_cm_data {
	__be32 qpn; /* High byte MUST be ignored on receive */
	__be32 mtu;
};

/*
 * Quoting 10.3.1 Queue Pair and EE Context States:
 *
 * Note, for QPs that are associated with an SRQ, the Consumer should take the
 * QP through the Error State before invoking a Destroy QP or a Modify QP to the
 * Reset State.  The Consumer may invoke the Destroy QP without first performing
 * a Modify QP to the Error State and waiting for the Affiliated Asynchronous
 * Last WQE Reached Event. However, if the Consumer does not wait for the
 * Affiliated Asynchronous Last WQE Reached Event, then WQE and Data Segment
 * leakage may occur. Therefore, it is good programming practice to tear down a
 * QP that is associated with an SRQ by using the following process:
 *
 * - Put the QP in the Error State
 * - Wait for the Affiliated Asynchronous Last WQE Reached Event;
 * - either:
 *       drain the CQ by invoking the Poll CQ verb and either wait for CQ
 *       to be empty or the number of Poll CQ operations has exceeded
 *       CQ capacity size;
 * - or
 *       post another WR that completes on the same CQ and wait for this
 *       WR to return as a WC;
 * - and then invoke a Destroy QP or Reset QP.
 *
 * We use the second option and wait for a completion on the
 * rx_drain_qp before destroying QPs attached to our SRQ.
 */

enum ipoib_cm_state {
	IPOIB_CM_RX_LIVE,
	IPOIB_CM_RX_ERROR, /* Ignored by stale task */
	IPOIB_CM_RX_FLUSH  /* Last WQE Reached event observed */
};

struct ipoib_cm_rx {
	struct ib_cm_id     *id;
	struct ib_qp        *qp;
	struct list_head     list;
	struct net_device   *dev;
	unsigned long        jiffies;
	enum ipoib_cm_state  state;
};

struct ipoib_cm_tx {
	struct ib_cm_id     *id;
	struct ib_cq        *cq;
	struct ib_qp        *qp;
	struct list_head     list;
	struct net_device   *dev;
	struct ipoib_neigh  *neigh;
	struct ipoib_path   *path;
	struct ipoib_tx_buf *tx_ring;
	unsigned             tx_head;
	unsigned             tx_tail;
	unsigned long        flags;
	u32                  mtu;
	struct ib_wc         ibwc[IPOIB_NUM_WC];
};

struct ipoib_cm_rx_buf {
	struct sk_buff *skb;
	u64 mapping[IPOIB_CM_RX_SG];
};

struct ipoib_cm_dev_priv {
	struct ib_srq  	       *srq;
	struct ipoib_cm_rx_buf *srq_ring;
	struct ib_cm_id        *id;
	struct ib_qp           *rx_drain_qp;   /* generates WR described in 10.3.1 */
	struct list_head        passive_ids;   /* state: LIVE */
	struct list_head        rx_error_list; /* state: ERROR */
	struct list_head        rx_flush_list; /* state: FLUSH, drain not started */
	struct list_head        rx_drain_list; /* state: FLUSH, drain started */
	struct list_head        rx_reap_list;  /* state: FLUSH, drain done */
	struct work_struct      start_task;
	struct work_struct      reap_task;
	struct work_struct      skb_task;
	struct work_struct      rx_reap_task;
	struct delayed_work     stale_task;
	struct sk_buff_head     skb_queue;
	struct list_head        start_list;
	struct list_head        reap_list;
	struct ib_wc            ibwc[IPOIB_NUM_WC];
	struct ib_sge           rx_sge[IPOIB_CM_RX_SG];
	struct ib_recv_wr       rx_wr;
};

/*
 * Device private locking: tx_lock protects members used in TX fast
 * path (and we use LLTX so upper layers don't do extra locking).
 * lock protects everything else.  lock nests inside of tx_lock (ie
 * tx_lock must be acquired first if needed).
 */
struct ipoib_dev_priv {
	spinlock_t lock;

	struct net_device *dev;

	unsigned long flags;

	struct mutex mcast_mutex;
	struct mutex vlan_mutex;

	struct rb_root  path_tree;
	struct list_head path_list;

	struct ipoib_mcast *broadcast;
	struct list_head multicast_list;
	struct rb_root multicast_tree;

	struct delayed_work pkey_poll_task;
	struct delayed_work mcast_task;
	struct work_struct flush_task;
	struct work_struct restart_task;
	struct delayed_work ah_reap_task;
	struct work_struct pkey_event_task;

	struct ib_device *ca;
	u8            	  port;
	u16           	  pkey;
	u16               pkey_index;
	struct ib_pd  	 *pd;
	struct ib_mr  	 *mr;
	struct ib_cq  	 *cq;
	struct ib_qp  	 *qp;
	u32           	  qkey;

	union ib_gid local_gid;
	u16          local_lid;

	unsigned int admin_mtu;
	unsigned int mcast_mtu;

	struct ipoib_rx_buf *rx_ring;

	spinlock_t           tx_lock;
	struct ipoib_tx_buf *tx_ring;
	unsigned             tx_head;
	unsigned             tx_tail;
	struct ib_sge        tx_sge;
	struct ib_send_wr    tx_wr;

	struct ib_wc ibwc[IPOIB_NUM_WC];

	struct list_head dead_ahs;

	struct ib_event_handler event_handler;

	struct net_device_stats stats;

	struct net_device *parent;
	struct list_head child_intfs;
	struct list_head list;

#ifdef CONFIG_INFINIBAND_IPOIB_CM
	struct ipoib_cm_dev_priv cm;
#endif

#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
	struct list_head fs_list;
	struct dentry *mcg_dentry;
	struct dentry *path_dentry;
#endif
};

struct ipoib_ah {
	struct net_device *dev;
	struct ib_ah      *ah;
	struct list_head   list;
	struct kref        ref;
	unsigned           last_send;
};

struct ipoib_path {
	struct net_device    *dev;
	struct ib_sa_path_rec pathrec;
	struct ipoib_ah      *ah;
	struct sk_buff_head   queue;

	struct list_head      neigh_list;

	int                   query_id;
	struct ib_sa_query   *query;
	struct completion     done;

	struct rb_node        rb_node;
	struct list_head      list;
};

struct ipoib_neigh {
	struct ipoib_ah    *ah;
#ifdef CONFIG_INFINIBAND_IPOIB_CM
	struct ipoib_cm_tx *cm;
#endif
	union ib_gid        dgid;
	struct sk_buff_head queue;

	struct neighbour   *neighbour;

	struct list_head    list;
};

/*
 * We stash a pointer to our private neighbour information after our
 * hardware address in neigh->ha.  The ALIGN() expression here makes
 * sure that this pointer is stored aligned so that an unaligned
 * load is not needed to dereference it.
 */
static inline struct ipoib_neigh **to_ipoib_neigh(struct neighbour *neigh)
{
	return (void*) neigh + ALIGN(offsetof(struct neighbour, ha) +
				     INFINIBAND_ALEN, sizeof(void *));
}

struct ipoib_neigh *ipoib_neigh_alloc(struct neighbour *neigh);
void ipoib_neigh_free(struct net_device *dev, struct ipoib_neigh *neigh);

extern struct workqueue_struct *ipoib_workqueue;

/* functions */

int ipoib_poll(struct net_device *dev, int *budget);
void ipoib_ib_completion(struct ib_cq *cq, void *dev_ptr);

struct ipoib_ah *ipoib_create_ah(struct net_device *dev,
				 struct ib_pd *pd, struct ib_ah_attr *attr);
void ipoib_free_ah(struct kref *kref);
static inline void ipoib_put_ah(struct ipoib_ah *ah)
{
	kref_put(&ah->ref, ipoib_free_ah);
}

int ipoib_open(struct net_device *dev);
int ipoib_add_pkey_attr(struct net_device *dev);

void ipoib_send(struct net_device *dev, struct sk_buff *skb,
		struct ipoib_ah *address, u32 qpn);
void ipoib_reap_ah(struct work_struct *work);

void ipoib_flush_paths(struct net_device *dev);
struct ipoib_dev_priv *ipoib_intf_alloc(const char *format);

int ipoib_ib_dev_init(struct net_device *dev, struct ib_device *ca, int port);
void ipoib_ib_dev_flush(struct work_struct *work);
void ipoib_pkey_event(struct work_struct *work);
void ipoib_ib_dev_cleanup(struct net_device *dev);

int ipoib_ib_dev_open(struct net_device *dev);
int ipoib_ib_dev_up(struct net_device *dev);
int ipoib_ib_dev_down(struct net_device *dev, int flush);
int ipoib_ib_dev_stop(struct net_device *dev, int flush);

int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port);
void ipoib_dev_cleanup(struct net_device *dev);

void ipoib_mcast_join_task(struct work_struct *work);
void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb);

void ipoib_mcast_restart_task(struct work_struct *work);
int ipoib_mcast_start_thread(struct net_device *dev);
int ipoib_mcast_stop_thread(struct net_device *dev, int flush);

void ipoib_mcast_dev_down(struct net_device *dev);
void ipoib_mcast_dev_flush(struct net_device *dev);

#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev);
int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter);
void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter,
				  union ib_gid *gid,
				  unsigned long *created,
				  unsigned int *queuelen,
				  unsigned int *complete,
				  unsigned int *send_only);

struct ipoib_path_iter *ipoib_path_iter_init(struct net_device *dev);
int ipoib_path_iter_next(struct ipoib_path_iter *iter);
void ipoib_path_iter_read(struct ipoib_path_iter *iter,
			  struct ipoib_path *path);
#endif

int ipoib_mcast_attach(struct net_device *dev, u16 mlid,
		       union ib_gid *mgid);
int ipoib_mcast_detach(struct net_device *dev, u16 mlid,
		       union ib_gid *mgid);

int ipoib_init_qp(struct net_device *dev);
int ipoib_transport_dev_init(struct net_device *dev, struct ib_device *ca);
void ipoib_transport_dev_cleanup(struct net_device *dev);

void ipoib_event(struct ib_event_handler *handler,
		 struct ib_event *record);

int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey);
int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey);

void ipoib_pkey_poll(struct work_struct *work);
int ipoib_pkey_dev_delay_open(struct net_device *dev);
void ipoib_drain_cq(struct net_device *dev);

#ifdef CONFIG_INFINIBAND_IPOIB_CM

#define IPOIB_FLAGS_RC          0x80
#define IPOIB_FLAGS_UC          0x40

/* We don't support UC connections at the moment */
#define IPOIB_CM_SUPPORTED(ha)   (ha[0] & (IPOIB_FLAGS_RC))

static inline int ipoib_cm_admin_enabled(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	return IPOIB_CM_SUPPORTED(dev->dev_addr) &&
		test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
}

static inline int ipoib_cm_enabled(struct net_device *dev, struct neighbour *n)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	return IPOIB_CM_SUPPORTED(n->ha) &&
		test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
}

static inline int ipoib_cm_up(struct ipoib_neigh *neigh)

{
	return test_bit(IPOIB_FLAG_OPER_UP, &neigh->cm->flags);
}

static inline struct ipoib_cm_tx *ipoib_cm_get(struct ipoib_neigh *neigh)
{
	return neigh->cm;
}

static inline void ipoib_cm_set(struct ipoib_neigh *neigh, struct ipoib_cm_tx *tx)
{
	neigh->cm = tx;
}

void ipoib_cm_send(struct net_device *dev, struct sk_buff *skb, struct ipoib_cm_tx *tx);
int ipoib_cm_dev_open(struct net_device *dev);
void ipoib_cm_dev_stop(struct net_device *dev);
int ipoib_cm_dev_init(struct net_device *dev);
int ipoib_cm_add_mode_attr(struct net_device *dev);
void ipoib_cm_dev_cleanup(struct net_device *dev);
struct ipoib_cm_tx *ipoib_cm_create_tx(struct net_device *dev, struct ipoib_path *path,
				    struct ipoib_neigh *neigh);
void ipoib_cm_destroy_tx(struct ipoib_cm_tx *tx);
void ipoib_cm_skb_too_long(struct net_device* dev, struct sk_buff *skb,
			   unsigned int mtu);
void ipoib_cm_handle_rx_wc(struct net_device *dev, struct ib_wc *wc);
#else

struct ipoib_cm_tx;

static inline int ipoib_cm_admin_enabled(struct net_device *dev)
{
	return 0;
}
static inline int ipoib_cm_enabled(struct net_device *dev, struct neighbour *n)

{
	return 0;
}

static inline int ipoib_cm_up(struct ipoib_neigh *neigh)

{
	return 0;
}

static inline struct ipoib_cm_tx *ipoib_cm_get(struct ipoib_neigh *neigh)
{
	return NULL;
}

static inline void ipoib_cm_set(struct ipoib_neigh *neigh, struct ipoib_cm_tx *tx)
{
}

static inline
void ipoib_cm_send(struct net_device *dev, struct sk_buff *skb, struct ipoib_cm_tx *tx)
{
	return;
}

static inline
int ipoib_cm_dev_open(struct net_device *dev)
{
	return 0;
}

static inline
void ipoib_cm_dev_stop(struct net_device *dev)
{
	return;
}

static inline
int ipoib_cm_dev_init(struct net_device *dev)
{
	return -ENOSYS;
}

static inline
void ipoib_cm_dev_cleanup(struct net_device *dev)
{
	return;
}

static inline
struct ipoib_cm_tx *ipoib_cm_create_tx(struct net_device *dev, struct ipoib_path *path,
				    struct ipoib_neigh *neigh)
{
	return NULL;
}

static inline
void ipoib_cm_destroy_tx(struct ipoib_cm_tx *tx)
{
	return;
}

static inline
int ipoib_cm_add_mode_attr(struct net_device *dev)
{
	return 0;
}

static inline void ipoib_cm_skb_too_long(struct net_device* dev, struct sk_buff *skb,
					 unsigned int mtu)
{
	dev_kfree_skb_any(skb);
}

static inline void ipoib_cm_handle_rx_wc(struct net_device *dev, struct ib_wc *wc)
{
}

#endif

#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
void ipoib_create_debug_files(struct net_device *dev);
void ipoib_delete_debug_files(struct net_device *dev);
int ipoib_register_debugfs(void);
void ipoib_unregister_debugfs(void);
#else
static inline void ipoib_create_debug_files(struct net_device *dev) { }
static inline void ipoib_delete_debug_files(struct net_device *dev) { }
static inline int ipoib_register_debugfs(void) { return 0; }
static inline void ipoib_unregister_debugfs(void) { }
#endif


#define ipoib_printk(level, priv, format, arg...)	\
	printk(level "%s: " format, ((struct ipoib_dev_priv *) priv)->dev->name , ## arg)
#define ipoib_warn(priv, format, arg...)		\
	ipoib_printk(KERN_WARNING, priv, format , ## arg)

extern int ipoib_sendq_size;
extern int ipoib_recvq_size;

extern struct ib_sa_client ipoib_sa_client;

#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
extern int ipoib_debug_level;

#define ipoib_dbg(priv, format, arg...)			\
	do {					        \
		if (ipoib_debug_level > 0)			\
			ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
	} while (0)
#define ipoib_dbg_mcast(priv, format, arg...)		\
	do {					        \
		if (mcast_debug_level > 0)		\
			ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
	} while (0)
#else /* CONFIG_INFINIBAND_IPOIB_DEBUG */
#define ipoib_dbg(priv, format, arg...)			\
	do { (void) (priv); } while (0)
#define ipoib_dbg_mcast(priv, format, arg...)		\
	do { (void) (priv); } while (0)
#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */

#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG_DATA
#define ipoib_dbg_data(priv, format, arg...)		\
	do {					        \
		if (data_debug_level > 0)		\
			ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
	} while (0)
#else /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */
#define ipoib_dbg_data(priv, format, arg...)		\
	do { (void) (priv); } while (0)
#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */


#define IPOIB_GID_FMT		"%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:" \
				"%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x"

#define IPOIB_GID_RAW_ARG(gid)	((u8 *)(gid))[0], \
				((u8 *)(gid))[1], \
				((u8 *)(gid))[2], \
				((u8 *)(gid))[3], \
				((u8 *)(gid))[4], \
				((u8 *)(gid))[5], \
				((u8 *)(gid))[6], \
				((u8 *)(gid))[7], \
				((u8 *)(gid))[8], \
				((u8 *)(gid))[9], \
				((u8 *)(gid))[10],\
				((u8 *)(gid))[11],\
				((u8 *)(gid))[12],\
				((u8 *)(gid))[13],\
				((u8 *)(gid))[14],\
				((u8 *)(gid))[15]

#define IPOIB_GID_ARG(gid)	IPOIB_GID_RAW_ARG((gid).raw)

#define IPOIB_QPN(ha) (be32_to_cpup((__be32 *) ha) & 0xffffff)

#endif /* _IPOIB_H */
Commit	Line	Data
1da177e4 LT	1	/*
1da177e4 LT	2	* Copyright (c) 2004, 2005 Topspin Communications. All rights reserved.
2a1d9b7f RD	3	* Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
2a1d9b7f RD	4	* Copyright (c) 2004 Voltaire, Inc. All rights reserved.
1da177e4 LT	5	*
	6	* This software is available to you under a choice of one of two
	7	* licenses. You may choose to be licensed under the terms of the GNU
	8	* General Public License (GPL) Version 2, available from the file
	9	* COPYING in the main directory of this source tree, or the
	10	* OpenIB.org BSD license below:
	11	*
	12	* Redistribution and use in source and binary forms, with or
	13	* without modification, are permitted provided that the following
	14	* conditions are met:
	15	*
	16	* - Redistributions of source code must retain the above
	17	* copyright notice, this list of conditions and the following
	18	* disclaimer.
	19	*
	20	* - Redistributions in binary form must reproduce the above
	21	* copyright notice, this list of conditions and the following
	22	* disclaimer in the documentation and/or other materials
	23	* provided with the distribution.
	24	*
	25	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	26	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	27	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	28	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	29	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	30	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	31	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	32	* SOFTWARE.
	33	*
	34	* $Id: ipoib.h 1358 2004-12-17 22:00:11Z roland $
	35	*/
	36
	37	#ifndef _IPOIB_H
	38	#define _IPOIB_H
	39
	40	#include <linux/list.h>
	41	#include <linux/skbuff.h>
	42	#include <linux/netdevice.h>
	43	#include <linux/workqueue.h>
1da177e4 LT	44	#include <linux/kref.h>
1da177e4 LT	45	#include <linux/if_infiniband.h>
95ed644f	46	#include <linux/mutex.h>
1da177e4 LT	47
	48	#include <net/neighbour.h>
	49
	50	#include <asm/atomic.h>
1da177e4	51
a4d61e84 RD	52	#include <rdma/ib_verbs.h>
	53	#include <rdma/ib_pack.h>
	54	#include <rdma/ib_sa.h>
1da177e4 LT	55
	56	/* constants */
	57
	58	enum {
	59	IPOIB_PACKET_SIZE = 2048,
	60	IPOIB_BUF_SIZE = IPOIB_PACKET_SIZE + IB_GRH_BYTES,
	61
	62	IPOIB_ENCAP_LEN = 4,
	63
839fcaba MT	64	IPOIB_CM_MTU = 0x10000 - 0x10, /* padding to align header to 16 */
	65	IPOIB_CM_BUF_SIZE = IPOIB_CM_MTU + IPOIB_ENCAP_LEN,
	66	IPOIB_CM_HEAD_SIZE = IPOIB_CM_BUF_SIZE % PAGE_SIZE,
	67	IPOIB_CM_RX_SG = ALIGN(IPOIB_CM_BUF_SIZE, PAGE_SIZE) / PAGE_SIZE,
1da177e4 LT	68	IPOIB_RX_RING_SIZE = 128,
1da177e4 LT	69	IPOIB_TX_RING_SIZE = 64,
0f485251 SM	70	IPOIB_MAX_QUEUE_SIZE = 8192,
0f485251 SM	71	IPOIB_MIN_QUEUE_SIZE = 2,
1da177e4 LT	72
	73	IPOIB_NUM_WC = 4,
	74
	75	IPOIB_MAX_PATH_REC_QUEUE = 3,
	76	IPOIB_MAX_MCAST_QUEUE = 3,
	77
	78	IPOIB_FLAG_OPER_UP = 0,
7a343d4c LA	79	IPOIB_FLAG_INITIALIZED = 1,
	80	IPOIB_FLAG_ADMIN_UP = 2,
	81	IPOIB_PKEY_ASSIGNED = 3,
	82	IPOIB_PKEY_STOP = 4,
	83	IPOIB_FLAG_SUBINTERFACE = 5,
	84	IPOIB_MCAST_RUN = 6,
	85	IPOIB_STOP_REAPER = 7,
	86	IPOIB_MCAST_STARTED = 8,
839fcaba MT	87	IPOIB_FLAG_NETIF_STOPPED = 9,
839fcaba MT	88	IPOIB_FLAG_ADMIN_CM = 10,
1da177e4 LT	89
	90	IPOIB_MAX_BACKOFF_SECONDS = 16,
	91
	92	IPOIB_MCAST_FLAG_FOUND = 0, /* used in set_multicast_list */
	93	IPOIB_MCAST_FLAG_SENDONLY = 1,
	94	IPOIB_MCAST_FLAG_BUSY = 2, /* joining or already joined */
	95	IPOIB_MCAST_FLAG_ATTACHED = 3,
	96	};
	97
839fcaba MT	98	#define IPOIB_OP_RECV (1ul << 31)
	99	#ifdef CONFIG_INFINIBAND_IPOIB_CM
	100	#define IPOIB_CM_OP_SRQ (1ul << 30)
	101	#else
	102	#define IPOIB_CM_OP_SRQ (0)
	103	#endif
	104
1da177e4 LT	105	/* structs */
	106
	107	struct ipoib_header {
97f52eb4 SH	108	__be16 proto;
97f52eb4 SH	109	u16 reserved;
1da177e4 LT	110	};
	111
	112	struct ipoib_pseudoheader {
	113	u8 hwaddr[INFINIBAND_ALEN];
	114	};
	115
	116	struct ipoib_mcast;
	117
1993d683 RD	118	struct ipoib_rx_buf {
1993d683 RD	119	struct sk_buff *skb;
37ccf9df	120	u64 mapping;
1993d683 RD	121	};
	122
	123	struct ipoib_tx_buf {
1da177e4	124	struct sk_buff *skb;
37ccf9df	125	u64 mapping;
1da177e4 LT	126	};
1da177e4 LT	127
839fcaba MT	128	struct ib_cm_id;
	129
	130	struct ipoib_cm_data {
	131	__be32 qpn; /* High byte MUST be ignored on receive */
	132	__be32 mtu;
	133	};
	134
518b1646 MT	135	/*
	136	* Quoting 10.3.1 Queue Pair and EE Context States:
	137	*
	138	* Note, for QPs that are associated with an SRQ, the Consumer should take the
	139	* QP through the Error State before invoking a Destroy QP or a Modify QP to the
	140	* Reset State. The Consumer may invoke the Destroy QP without first performing
	141	* a Modify QP to the Error State and waiting for the Affiliated Asynchronous
	142	* Last WQE Reached Event. However, if the Consumer does not wait for the
	143	* Affiliated Asynchronous Last WQE Reached Event, then WQE and Data Segment
	144	* leakage may occur. Therefore, it is good programming practice to tear down a
	145	* QP that is associated with an SRQ by using the following process:
	146	*
	147	* - Put the QP in the Error State
	148	* - Wait for the Affiliated Asynchronous Last WQE Reached Event;
	149	* - either:
	150	* drain the CQ by invoking the Poll CQ verb and either wait for CQ
	151	* to be empty or the number of Poll CQ operations has exceeded
	152	* CQ capacity size;
	153	* - or
	154	* post another WR that completes on the same CQ and wait for this
	155	* WR to return as a WC;
	156	* - and then invoke a Destroy QP or Reset QP.
	157	*
	158	* We use the second option and wait for a completion on the
	159	* rx_drain_qp before destroying QPs attached to our SRQ.
	160	*/
	161
	162	enum ipoib_cm_state {
	163	IPOIB_CM_RX_LIVE,
	164	IPOIB_CM_RX_ERROR, /* Ignored by stale task */
	165	IPOIB_CM_RX_FLUSH /* Last WQE Reached event observed */
	166	};
	167
839fcaba MT	168	struct ipoib_cm_rx {
	169	struct ib_cm_id *id;
	170	struct ib_qp *qp;
	171	struct list_head list;
	172	struct net_device *dev;
	173	unsigned long jiffies;
518b1646	174	enum ipoib_cm_state state;
839fcaba MT	175	};
	176
	177	struct ipoib_cm_tx {
	178	struct ib_cm_id *id;
	179	struct ib_cq *cq;
	180	struct ib_qp *qp;
	181	struct list_head list;
	182	struct net_device *dev;
	183	struct ipoib_neigh *neigh;
	184	struct ipoib_path *path;
	185	struct ipoib_tx_buf *tx_ring;
	186	unsigned tx_head;
	187	unsigned tx_tail;
	188	unsigned long flags;
	189	u32 mtu;
	190	struct ib_wc ibwc[IPOIB_NUM_WC];
	191	};
	192
	193	struct ipoib_cm_rx_buf {
	194	struct sk_buff *skb;
	195	u64 mapping[IPOIB_CM_RX_SG];
	196	};
	197
	198	struct ipoib_cm_dev_priv {
	199	struct ib_srq *srq;
	200	struct ipoib_cm_rx_buf *srq_ring;
	201	struct ib_cm_id *id;
518b1646 MT	202	struct ib_qp rx_drain_qp; / generates WR described in 10.3.1 */
	203	struct list_head passive_ids; /* state: LIVE */
	204	struct list_head rx_error_list; /* state: ERROR */
	205	struct list_head rx_flush_list; /* state: FLUSH, drain not started */
	206	struct list_head rx_drain_list; /* state: FLUSH, drain started */
	207	struct list_head rx_reap_list; /* state: FLUSH, drain done */
839fcaba MT	208	struct work_struct start_task;
	209	struct work_struct reap_task;
	210	struct work_struct skb_task;
518b1646	211	struct work_struct rx_reap_task;
839fcaba MT	212	struct delayed_work stale_task;
	213	struct sk_buff_head skb_queue;
	214	struct list_head start_list;
	215	struct list_head reap_list;
	216	struct ib_wc ibwc[IPOIB_NUM_WC];
	217	struct ib_sge rx_sge[IPOIB_CM_RX_SG];
	218	struct ib_recv_wr rx_wr;
	219	};
	220
1da177e4 LT	221	/*
	222	* Device private locking: tx_lock protects members used in TX fast
	223	* path (and we use LLTX so upper layers don't do extra locking).
	224	* lock protects everything else. lock nests inside of tx_lock (ie
	225	* tx_lock must be acquired first if needed).
	226	*/
	227	struct ipoib_dev_priv {
	228	spinlock_t lock;
	229
	230	struct net_device *dev;
	231
	232	unsigned long flags;
	233
95ed644f IM	234	struct mutex mcast_mutex;
95ed644f IM	235	struct mutex vlan_mutex;
1da177e4 LT	236
	237	struct rb_root path_tree;
	238	struct list_head path_list;
	239
	240	struct ipoib_mcast *broadcast;
	241	struct list_head multicast_list;
	242	struct rb_root multicast_tree;
	243
26bbf13c	244	struct delayed_work pkey_poll_task;
c4028958	245	struct delayed_work mcast_task;
1da177e4 LT	246	struct work_struct flush_task;
1da177e4 LT	247	struct work_struct restart_task;
c4028958	248	struct delayed_work ah_reap_task;
26bbf13c	249	struct work_struct pkey_event_task;
1da177e4 LT	250
	251	struct ib_device *ca;
	252	u8 port;
	253	u16 pkey;
26bbf13c	254	u16 pkey_index;
1da177e4 LT	255	struct ib_pd *pd;
	256	struct ib_mr *mr;
	257	struct ib_cq *cq;
	258	struct ib_qp *qp;
	259	u32 qkey;
	260
	261	union ib_gid local_gid;
	262	u16 local_lid;
1da177e4 LT	263
	264	unsigned int admin_mtu;
	265	unsigned int mcast_mtu;
	266
1993d683	267	struct ipoib_rx_buf *rx_ring;
1da177e4	268
1993d683 RD	269	spinlock_t tx_lock;
	270	struct ipoib_tx_buf *tx_ring;
	271	unsigned tx_head;
	272	unsigned tx_tail;
	273	struct ib_sge tx_sge;
	274	struct ib_send_wr tx_wr;
1da177e4 LT	275
	276	struct ib_wc ibwc[IPOIB_NUM_WC];
	277
	278	struct list_head dead_ahs;
	279
	280	struct ib_event_handler event_handler;
	281
	282	struct net_device_stats stats;
	283
	284	struct net_device *parent;
	285	struct list_head child_intfs;
	286	struct list_head list;
	287
839fcaba MT	288	#ifdef CONFIG_INFINIBAND_IPOIB_CM
	289	struct ipoib_cm_dev_priv cm;
	290	#endif
	291
1da177e4 LT	292	#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
	293	struct list_head fs_list;
	294	struct dentry *mcg_dentry;
1732b0ef	295	struct dentry *path_dentry;
1da177e4 LT	296	#endif
	297	};
	298
	299	struct ipoib_ah {
	300	struct net_device *dev;
	301	struct ib_ah *ah;
	302	struct list_head list;
	303	struct kref ref;
	304	unsigned last_send;
	305	};
	306
	307	struct ipoib_path {
	308	struct net_device *dev;
	309	struct ib_sa_path_rec pathrec;
	310	struct ipoib_ah *ah;
	311	struct sk_buff_head queue;
	312
	313	struct list_head neigh_list;
	314
	315	int query_id;
	316	struct ib_sa_query *query;
	317	struct completion done;
	318
	319	struct rb_node rb_node;
	320	struct list_head list;
	321	};
	322
	323	struct ipoib_neigh {
	324	struct ipoib_ah *ah;
839fcaba MT	325	#ifdef CONFIG_INFINIBAND_IPOIB_CM
	326	struct ipoib_cm_tx *cm;
	327	#endif
8a7f7521	328	union ib_gid dgid;
1da177e4 LT	329	struct sk_buff_head queue;
	330
	331	struct neighbour *neighbour;
	332
	333	struct list_head list;
	334	};
	335
44af79f9 MT	336	/*
	337	* We stash a pointer to our private neighbour information after our
	338	* hardware address in neigh->ha. The ALIGN() expression here makes
	339	* sure that this pointer is stored aligned so that an unaligned
	340	* load is not needed to dereference it.
	341	*/
1da177e4 LT	342	static inline struct ipoib_neigh *to_ipoib_neigh(struct neighbour neigh)
1da177e4 LT	343	{
44af79f9 MT	344	return (void*) neigh + ALIGN(offsetof(struct neighbour, ha) +
44af79f9 MT	345	INFINIBAND_ALEN, sizeof(void *));
1da177e4 LT	346	}
1da177e4 LT	347
d2e0655e	348	struct ipoib_neigh ipoib_neigh_alloc(struct neighbour neigh);
2745b5b7	349	void ipoib_neigh_free(struct net_device dev, struct ipoib_neigh neigh);
d2e0655e	350
1da177e4 LT	351	extern struct workqueue_struct *ipoib_workqueue;
	352
	353	/* functions */
	354
8d1cc86a	355	int ipoib_poll(struct net_device dev, int budget);
1da177e4 LT	356	void ipoib_ib_completion(struct ib_cq cq, void dev_ptr);
	357
	358	struct ipoib_ah ipoib_create_ah(struct net_device dev,
	359	struct ib_pd pd, struct ib_ah_attr attr);
	360	void ipoib_free_ah(struct kref *kref);
	361	static inline void ipoib_put_ah(struct ipoib_ah *ah)
	362	{
	363	kref_put(&ah->ref, ipoib_free_ah);
	364	}
	365
8ae5a8a2	366	int ipoib_open(struct net_device *dev);
1da177e4 LT	367	int ipoib_add_pkey_attr(struct net_device *dev);
	368
	369	void ipoib_send(struct net_device dev, struct sk_buff skb,
	370	struct ipoib_ah *address, u32 qpn);
c4028958	371	void ipoib_reap_ah(struct work_struct *work);
1da177e4 LT	372
	373	void ipoib_flush_paths(struct net_device *dev);
	374	struct ipoib_dev_priv ipoib_intf_alloc(const char format);
	375
	376	int ipoib_ib_dev_init(struct net_device dev, struct ib_device ca, int port);
c4028958	377	void ipoib_ib_dev_flush(struct work_struct *work);
26bbf13c	378	void ipoib_pkey_event(struct work_struct *work);
1da177e4 LT	379	void ipoib_ib_dev_cleanup(struct net_device *dev);
	380
	381	int ipoib_ib_dev_open(struct net_device *dev);
	382	int ipoib_ib_dev_up(struct net_device *dev);
0b3ea082	383	int ipoib_ib_dev_down(struct net_device *dev, int flush);
26bbf13c	384	int ipoib_ib_dev_stop(struct net_device *dev, int flush);
1da177e4 LT	385
	386	int ipoib_dev_init(struct net_device dev, struct ib_device ca, int port);
	387	void ipoib_dev_cleanup(struct net_device *dev);
	388
c4028958	389	void ipoib_mcast_join_task(struct work_struct *work);
37c22a77	390	void ipoib_mcast_send(struct net_device dev, void mgid, struct sk_buff *skb);
1da177e4	391
c4028958	392	void ipoib_mcast_restart_task(struct work_struct *work);
1da177e4	393	int ipoib_mcast_start_thread(struct net_device *dev);
8d2cae06	394	int ipoib_mcast_stop_thread(struct net_device *dev, int flush);
1da177e4 LT	395
	396	void ipoib_mcast_dev_down(struct net_device *dev);
	397	void ipoib_mcast_dev_flush(struct net_device *dev);
	398
8ae5a8a2	399	#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
1da177e4	400	struct ipoib_mcast_iter ipoib_mcast_iter_init(struct net_device dev);
1da177e4 LT	401	int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter);
	402	void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter,
	403	union ib_gid *gid,
	404	unsigned long *created,
	405	unsigned int *queuelen,
	406	unsigned int *complete,
	407	unsigned int *send_only);
1732b0ef RD	408
	409	struct ipoib_path_iter ipoib_path_iter_init(struct net_device dev);
	410	int ipoib_path_iter_next(struct ipoib_path_iter *iter);
	411	void ipoib_path_iter_read(struct ipoib_path_iter *iter,
	412	struct ipoib_path *path);
8ae5a8a2	413	#endif
1da177e4 LT	414
	415	int ipoib_mcast_attach(struct net_device *dev, u16 mlid,
	416	union ib_gid *mgid);
	417	int ipoib_mcast_detach(struct net_device *dev, u16 mlid,
	418	union ib_gid *mgid);
	419
5b6810e0	420	int ipoib_init_qp(struct net_device *dev);
1da177e4 LT	421	int ipoib_transport_dev_init(struct net_device dev, struct ib_device ca);
	422	void ipoib_transport_dev_cleanup(struct net_device *dev);
	423
	424	void ipoib_event(struct ib_event_handler *handler,
	425	struct ib_event *record);
	426
	427	int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey);
	428	int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey);
	429
c4028958	430	void ipoib_pkey_poll(struct work_struct *work);
1da177e4	431	int ipoib_pkey_dev_delay_open(struct net_device *dev);
2dfbfc37	432	void ipoib_drain_cq(struct net_device *dev);
1da177e4	433
839fcaba MT	434	#ifdef CONFIG_INFINIBAND_IPOIB_CM
	435
	436	#define IPOIB_FLAGS_RC 0x80
	437	#define IPOIB_FLAGS_UC 0x40
	438
	439	/* We don't support UC connections at the moment */
	440	#define IPOIB_CM_SUPPORTED(ha) (ha[0] & (IPOIB_FLAGS_RC))
	441
	442	static inline int ipoib_cm_admin_enabled(struct net_device *dev)
	443	{
	444	struct ipoib_dev_priv *priv = netdev_priv(dev);
	445	return IPOIB_CM_SUPPORTED(dev->dev_addr) &&
	446	test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
	447	}
	448
	449	static inline int ipoib_cm_enabled(struct net_device dev, struct neighbour n)
	450	{
	451	struct ipoib_dev_priv *priv = netdev_priv(dev);
	452	return IPOIB_CM_SUPPORTED(n->ha) &&
	453	test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
	454	}
	455
	456	static inline int ipoib_cm_up(struct ipoib_neigh *neigh)
	457
	458	{
	459	return test_bit(IPOIB_FLAG_OPER_UP, &neigh->cm->flags);
	460	}
	461
	462	static inline struct ipoib_cm_tx ipoib_cm_get(struct ipoib_neigh neigh)
	463	{
	464	return neigh->cm;
	465	}
	466
	467	static inline void ipoib_cm_set(struct ipoib_neigh neigh, struct ipoib_cm_tx tx)
	468	{
	469	neigh->cm = tx;
	470	}
	471
	472	void ipoib_cm_send(struct net_device dev, struct sk_buff skb, struct ipoib_cm_tx *tx);
	473	int ipoib_cm_dev_open(struct net_device *dev);
	474	void ipoib_cm_dev_stop(struct net_device *dev);
	475	int ipoib_cm_dev_init(struct net_device *dev);
	476	int ipoib_cm_add_mode_attr(struct net_device *dev);
	477	void ipoib_cm_dev_cleanup(struct net_device *dev);
	478	struct ipoib_cm_tx ipoib_cm_create_tx(struct net_device dev, struct ipoib_path *path,
	479	struct ipoib_neigh *neigh);
	480	void ipoib_cm_destroy_tx(struct ipoib_cm_tx *tx);
	481	void ipoib_cm_skb_too_long(struct net_device* dev, struct sk_buff *skb,
	482	unsigned int mtu);
	483	void ipoib_cm_handle_rx_wc(struct net_device dev, struct ib_wc wc);
	484	#else
	485
	486	struct ipoib_cm_tx;
	487
	488	static inline int ipoib_cm_admin_enabled(struct net_device *dev)
	489	{
	490	return 0;
	491	}
	492	static inline int ipoib_cm_enabled(struct net_device dev, struct neighbour n)
	493
	494	{
	495	return 0;
	496	}
	497
498	static inline int ipoib_cm_up(struct ipoib_neigh *neigh)
499
500	{
501	return 0;
502	}
503
504	static inline struct ipoib_cm_tx ipoib_cm_get(struct ipoib_neigh neigh)
505	{
506	return NULL;
507	}
508
509	static inline void ipoib_cm_set(struct ipoib_neigh neigh, struct ipoib_cm_tx tx)
510	{
511	}
512
513	static inline
514	void ipoib_cm_send(struct net_device dev, struct sk_buff skb, struct ipoib_cm_tx *tx)
515	{
516	return;
517	}
518
519	static inline
520	int ipoib_cm_dev_open(struct net_device *dev)
521	{
522	return 0;
523	}
524
525	static inline
526	void ipoib_cm_dev_stop(struct net_device *dev)
527	{
528	return;
529	}
530
531	static inline
532	int ipoib_cm_dev_init(struct net_device *dev)
533	{
534	return -ENOSYS;
535	}
536
537	static inline
538	void ipoib_cm_dev_cleanup(struct net_device *dev)
539	{
540	return;
541	}
542
543	static inline
544	struct ipoib_cm_tx ipoib_cm_create_tx(struct net_device dev, struct ipoib_path *path,
545	struct ipoib_neigh *neigh)
546	{
547	return NULL;
548	}
549
550	static inline
551	void ipoib_cm_destroy_tx(struct ipoib_cm_tx *tx)
552	{
553	return;
554	}
555
556	static inline
557	int ipoib_cm_add_mode_attr(struct net_device *dev)
558	{
559	return 0;
560	}
561
562	static inline void ipoib_cm_skb_too_long(struct net_device* dev, struct sk_buff *skb,
563	unsigned int mtu)
564	{
565	dev_kfree_skb_any(skb);
566	}
567
568	static inline void ipoib_cm_handle_rx_wc(struct net_device dev, struct ib_wc wc)
569	{
570	}
571
572	#endif
573
1da177e4	574	#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
1732b0ef RD	575	void ipoib_create_debug_files(struct net_device *dev);
1732b0ef RD	576	void ipoib_delete_debug_files(struct net_device *dev);
1da177e4 LT	577	int ipoib_register_debugfs(void);
	578	void ipoib_unregister_debugfs(void);
	579	#else
1732b0ef RD	580	static inline void ipoib_create_debug_files(struct net_device *dev) { }
1732b0ef RD	581	static inline void ipoib_delete_debug_files(struct net_device *dev) { }
1da177e4 LT	582	static inline int ipoib_register_debugfs(void) { return 0; }
	583	static inline void ipoib_unregister_debugfs(void) { }
	584	#endif
	585
	586
	587	#define ipoib_printk(level, priv, format, arg...) \
	588	printk(level "%s: " format, ((struct ipoib_dev_priv *) priv)->dev->name , ## arg)
	589	#define ipoib_warn(priv, format, arg...) \
	590	ipoib_printk(KERN_WARNING, priv, format , ## arg)
	591
0f485251 SM	592	extern int ipoib_sendq_size;
0f485251 SM	593	extern int ipoib_recvq_size;
1da177e4	594
c1a0b23b MT	595	extern struct ib_sa_client ipoib_sa_client;
c1a0b23b MT	596
1da177e4 LT	597	#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
	598	extern int ipoib_debug_level;
	599
	600	#define ipoib_dbg(priv, format, arg...) \
	601	do { \
	602	if (ipoib_debug_level > 0) \
	603	ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
	604	} while (0)
	605	#define ipoib_dbg_mcast(priv, format, arg...) \
	606	do { \
	607	if (mcast_debug_level > 0) \
	608	ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
	609	} while (0)
	610	#else /* CONFIG_INFINIBAND_IPOIB_DEBUG */
	611	#define ipoib_dbg(priv, format, arg...) \
	612	do { (void) (priv); } while (0)
	613	#define ipoib_dbg_mcast(priv, format, arg...) \
	614	do { (void) (priv); } while (0)
	615	#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */
	616
	617	#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG_DATA
	618	#define ipoib_dbg_data(priv, format, arg...) \
	619	do { \
	620	if (data_debug_level > 0) \
	621	ipoib_printk(KERN_DEBUG, priv, format , ## arg); \
	622	} while (0)
	623	#else /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */
	624	#define ipoib_dbg_data(priv, format, arg...) \
	625	do { (void) (priv); } while (0)
	626	#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */
	627
	628
37c22a77 JM	629	#define IPOIB_GID_FMT "%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:" \
	630	"%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x"
	631
	632	#define IPOIB_GID_RAW_ARG(gid) ((u8 *)(gid))[0], \
	633	((u8 *)(gid))[1], \
	634	((u8 *)(gid))[2], \
	635	((u8 *)(gid))[3], \
	636	((u8 *)(gid))[4], \
	637	((u8 *)(gid))[5], \
	638	((u8 *)(gid))[6], \
	639	((u8 *)(gid))[7], \
	640	((u8 *)(gid))[8], \
	641	((u8 *)(gid))[9], \
	642	((u8 *)(gid))[10],\
	643	((u8 *)(gid))[11],\
	644	((u8 *)(gid))[12],\
	645	((u8 *)(gid))[13],\
	646	((u8 *)(gid))[14],\
	647	((u8 *)(gid))[15]
	648
	649	#define IPOIB_GID_ARG(gid) IPOIB_GID_RAW_ARG((gid).raw)
1da177e4	650
839fcaba MT	651	#define IPOIB_QPN(ha) (be32_to_cpup((__be32 *) ha) & 0xffffff)
839fcaba MT	652
1da177e4	653	#endif /* _IPOIB_H */