/*
 * Copyright (c) 2007-2009 Chelsio, Inc. All rights reserved.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the LICENSE file included in this
 * release for licensing terms and conditions.
 */
#ifndef __TOM_COMPAT_2_4_H
#define __TOM_COMPAT_2_4_H

#include <linux/version.h>
#include <linux/hugetlb.h>

/* XXX Only built against 2.4.21 */
#if LINUX_VERSION_CODE != KERNEL_VERSION(2,4,21)
#endif

/*
 * Definitions here are mostly borrowed from cxgb3/linux_2_4_compat.h
 * and from earliest kernel version in tom_compat_2_6.h.
 */

/******************************************************************************
 * directives
 ******************************************************************************/
#define	__read_mostly
#define	__user
#define	__iomem
/* To avoid compiler warnings use 2.6 definitions */
#undef likely
#undef unlikely
#define likely(x)	__builtin_expect(!!(x), 1)
#define unlikely(x)	__builtin_expect(!!(x), 0)

/******************************************************************************
 * types
 ******************************************************************************/
typedef unsigned int gfp_t;

#define	__be64	u64
#define	__be32	u32
#define	__be16	u16

/******************************************************************************
 * debug compat
 ******************************************************************************/
#define WARN_ON(condition) do { \
        if (unlikely((condition)!=0)) { \
                printk("BUG: warning at %s:%d/%s()\n", __FILE__, __LINE__, __FUNCTION__); \
                dump_stack(); \
        } \
} while (0)

#define dev_printk(level, dev, format, arg...)  \
         printk(level  format , ## arg)

#define dev_err(dev, format, arg...)            \
        dev_printk(KERN_ERR , dev , format , ## arg)

#define dev_info(dev, format, arg...)            \
        dev_printk(KERN_INFO , dev , format , ## arg)

#define dev_warn(dev, format, arg...)            \
        dev_printk(KERN_WARNING , dev , format , ## arg)


/******************************************************************************
 * lock compatibility
 ******************************************************************************/
#define	DEFINE_MUTEX(l)			DECLARE_MUTEX((l))
#define mutex_lock(l)			down((l))
#define mutex_unlock(l)			up((l))
#define mutex_init(l)			sema_init((l), 1)
#define	DEFINE_RWLOCK(l)		rwlock_t (l) = RW_LOCK_UNLOCKED

#define spin_trylock_irq(lock) \
({ \
        local_irq_disable(); \
        spin_trylock(lock) ? \
        1 : ({ local_irq_enable(); 0;  }); \
})

/******************************************************************************
 * module compatibility
 ******************************************************************************/
#define	MODULE_VERSION(x)

#ifdef CONFIG_CHELSIO_T3_OFFLOAD_MODULE
/*
 * For module, just do regular module init.
 */
#define late_initcall(x)	module_init(x)
#else
/*
 * Since 2.4 does not provide ordered init calls,
 * must add explicit call at appropriate place during boot
 * (e.g. call t3_tom_init() from do_basic_setup() after TCP init)
 * -OR- ensure .o's are in appropriate link order but this is messy
 * since DRIVERS come before NETWORK.
 */
#define late_initcall(x)
#endif

/*
 * this macro only works for integer type parameters. If other types of
 * module parameters are added then this will need to be updated.
 */
#define module_param(param, type, perm)		MODULE_PARM(param, "i");

typedef void irqreturn_t;

#define SEQ_START_TOKEN ((void *)1)
/******************************************************************************
 * TCP compatibility
 ******************************************************************************/

#define TCP_NAGLE_OFF           1
#define TCP_NAGLE_CORK          2
#define TCP_CONGESTION  	13      /* Congestion control algorithm */
#define TCP_CA_NAME_MAX 	16

/* TCP congestion stuff. Added for compilation only */
#define TCP_CA_NAME_MAX 16
struct tcp_congestion_ops {
        void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb);

        char            name[TCP_CA_NAME_MAX];
        struct module   *owner;
};

static inline void tcp_v4_setup_caps(struct sock *sk, struct dst_entry *dst)
{
	sk->route_caps = dst->dev->features;
}

static inline void t3_set_ca_ops(struct sock *sk,
                                 struct tcp_congestion_ops *t_ops)
{}

#define t3_inet_inherit_port(p_hashinfo, lsk, newsk) tcp_inherit_port(lsk, newsk)
#define t3_inet_put_port(a, sk) tcp_put_port(sk)

/******************************************************************************
 * socket compatibility
 ******************************************************************************/
enum sock_flags {
        SOCK_DEAD,
        SOCK_DONE,
        SOCK_URGINLINE,
        SOCK_KEEPOPEN,
        SOCK_LINGER,
        SOCK_DESTROY,
        SOCK_BROADCAST,
        SOCK_TIMESTAMP,
        SOCK_ZAPPED,
        SOCK_USE_WRITE_QUEUE, /* whether to call sk->sk_write_space in sock_wfree */
        SOCK_DBG, /* %SO_DEBUG setting */
        SOCK_RCVTSTAMP, /* %SO_TIMESTAMP setting */
        SOCK_LOCALROUTE, /* route locally only, %SO_DONTROUTE setting */
        SOCK_QUEUE_SHRUNK, /* write queue has been shrunk recently */
};

/*
 * map 2.6 field names to 2.4 names
 */
#define sk_state		state
#define sk_sleep		sleep
#define sk_write_queue		write_queue
#define sk_userlocks		userlocks
#define sk_sndbuf		sndbuf
#define sk_prot			prot
#define sk_backlog_rcv		backlog_rcv
#define sk_write_space		write_space
#define sk_timer		timer
#define sk_dst_cache		dst_cache
#define sk_data_ready		data_ready
#define sk_user_data		user_data
#define sk_state_change		state_change
#define sk_err			err
#define sk_wmem_queued		wmem_queued
#define sk_error_report		error_report
#define sk_shutdown		shutdown
#define sk_receive_queue	receive_queue
#define sk_data_ready		data_ready
#define sk_bound_dev_if		bound_dev_if
#define sk_socket		socket
#define sk_sndmsg_page		sndmsg_page
#define sk_sndmsg_off		sndmsg_off
#define sk_allocation		allocation
#define sk_backlog		backlog
#define sk_lingertime		lingertime
#define sk_priority		priority
#define sk_callback_lock	callback_lock
#define sk_protinfo		pair
#define sk_family		family

/* Also a struct and function with same name so handle this one in C code!
#define sk_filter		filter
*/
#define sk_write_pending	tp_pinfo.af_tcp.write_pending
#define	sk_omem_alloc		omem_alloc

#define TCP_PAGE(sk)    (inet_sk(sk)->sndmsg_page)
#define TCP_OFF(sk)     (inet_sk(sk)->sndmsg_off)

/*
 * map 2.6 function calls to 2.4 ones defined in include/net/tcp.h
 */
#define sk_acceptq_removed	tcp_acceptq_removed
#define sk_acceptq_is_full	tcp_acceptq_is_full
#define sk_stream_min_wspace	tcp_min_write_space

#ifndef ATOMIC_ADD_RETURN
#if defined(CONFIG_X86_64)
static __inline__ int atomic_add_return(int i, atomic_t *v)
{
	int __i = i;
	__asm__ __volatile__(
		LOCK "xaddl %0, %1;"
		:"=r"(i)
		:"m"(v->counter), "0"(i));
	return i + __i;
} 

#elif defined(CONFIG_X86)
static __inline__ int atomic_add_return(int i, atomic_t *v)
{
	int __i;
#ifdef CONFIG_M386
	if(unlikely(boot_cpu_data.x86==3))
		goto no_xadd;
#endif
	/* Modern 486+ processor */
	__i = i;
	__asm__ __volatile__(
		LOCK "xaddl %0, %1;"
		:"=r"(i)
		:"m"(v->counter), "0"(i));
	return i + __i;

#ifdef CONFIG_M386
no_xadd: /* Legacy 386 processor */
	local_irq_disable();
	__i = atomic_read(v);
	atomic_set(v, i + __i);
	local_irq_enable();
	return i + __i;
#endif
} 

#elif defined(CONFIG_IA64)
#define atomic_add_return(i,v)						\
({									\
	int __ia64_aar_i = (i);						\
	(__builtin_constant_p(i)					\
	 && (   (__ia64_aar_i ==  1) || (__ia64_aar_i ==   4)		\
	     || (__ia64_aar_i ==  8) || (__ia64_aar_i ==  16)		\
	     || (__ia64_aar_i == -1) || (__ia64_aar_i ==  -4)		\
	     || (__ia64_aar_i == -8) || (__ia64_aar_i == -16)))		\
		? ia64_fetch_and_add(__ia64_aar_i, &(v)->counter)	\
		: ia64_atomic_add(__ia64_aar_i, v);			\
})
#endif
#endif /* ATOMIC_ADD_RETURN */

#define sock_owned_by_user(sk)  ((sk)->lock.users != 0)

#include "cpl_io_state.h"

static inline void sock_set_flag_val(struct sock *sk, enum sock_flags flag, int val)
{
	switch (flag) {
        	case SOCK_DEAD:
			sk->dead = val;
			break;
        	case SOCK_DONE:
			sk->done = val;
			break;
        	case SOCK_URGINLINE:
			sk->urginline = val;
			break;
        	case SOCK_KEEPOPEN:
			sk->keepopen = val;
			break;
        	case SOCK_LINGER:
			sk->linger = val;
			break;
        	case SOCK_DESTROY:
			sk->destroy = val;
			break;
        	case SOCK_BROADCAST:
			sk->broadcast = val;
			break;
        	case SOCK_USE_WRITE_QUEUE:
			sk->use_write_queue = val;
			break;
        	case SOCK_DBG:
			sk->debug = val;
			break;
        	case SOCK_RCVTSTAMP:
			sk->rcvtstamp = val;
			break;
        	case SOCK_ZAPPED:
			sk->zapped = val;
			break;
        	case SOCK_LOCALROUTE:
			sk->localroute = val;
			break;
        	case SOCK_TIMESTAMP:
			sk->rcvtstamp = val;
			break;
        	case SOCK_QUEUE_SHRUNK:
			sk->tp_pinfo.af_tcp.queue_shrunk = 1;
			break;
		case SOCK_NO_DDP:
		case SOCK_OFFLOADED:
			if (val)
				set_bit(flag, &CPL_IO_STATE(sk)->sk_flags);
			else
				clear_bit(flag, &CPL_IO_STATE(sk)->sk_flags);
			break;
		default:
			/* XXX In case new flag used but not handled here */
			printk("t3_tom: sock_set_flag_val: unknown flag\n");
			break;
	}
}

static inline void sock_reset_flag(struct sock *sk, enum sock_flags flag)
{
	sock_set_flag_val(sk, flag, 0);
}

static inline int sock_flag(struct sock *sk, enum sock_flags flag)
{
	int val = 0;

	switch (flag) {
        	case SOCK_DEAD:
			val = sk->dead;
			break;
        	case SOCK_DONE:
			val = sk->done;
			break;
        	case SOCK_URGINLINE:
			val = sk->urginline;
			break;
        	case SOCK_KEEPOPEN:
			val = sk->keepopen;
			break;
        	case SOCK_LINGER:
			val = sk->linger;
			break;
        	case SOCK_DESTROY:
			val = sk->destroy;
			break;
        	case SOCK_BROADCAST:
			val = sk->broadcast;
			break;
        	case SOCK_USE_WRITE_QUEUE:
			val = sk->use_write_queue;
			break;
        	case SOCK_DBG:
			val = sk->debug;
			break;
        	case SOCK_RCVTSTAMP:
			val = sk->rcvtstamp;
			break;
        	case SOCK_ZAPPED:
			val = sk->zapped;
			break;
        	case SOCK_LOCALROUTE:
			val = sk->localroute;
			break;
        	case SOCK_TIMESTAMP:
			val = sk->rcvtstamp;
			break;
        	case SOCK_QUEUE_SHRUNK:
			val = sk->tp_pinfo.af_tcp.queue_shrunk;
			break;
		case SOCK_NO_DDP:
		case SOCK_OFFLOADED:
			val = test_bit(flag, &CPL_IO_STATE(sk)->sk_flags);
			break;
		default:
			/* XXX In case new flag used but not handled here */
			printk("t3_tom: sock_flag: unknown flag\n");
			break;
	}
        return val;
}

static inline void sock_set_flag(struct sock *sk, enum sock_flags flag)
{
	sock_set_flag_val(sk, flag, 1);
}

static inline void sk_reset_timer(struct sock *sk, struct timer_list* timer,
                    unsigned long expires)
{
        if (!mod_timer(timer, expires))
                sock_hold(sk);
}

/*
 * map 2.6 function calls to 2.4 ones defined in net/ipv4/tcp.c
 * and in-lined here
 */
static inline void sk_eat_skb(struct sock *sk, struct sk_buff * skb)
{
	__skb_unlink(skb, &sk->receive_queue);
	__kfree_skb(skb);
}

static inline int sk_stream_error(struct sock *sk, int flags, int err)
{
	if (err == -EPIPE)
		err = sock_error(sk) ? : -EPIPE;
	if (err == -EPIPE && !(flags&MSG_NOSIGNAL))
		send_sig(SIGPIPE, current, 0);
	return err;
}

/* from 2.4 net/ipv4/ip_output.c */
static inline int
skb_can_coalesce(struct sk_buff *skb, int i, struct page *page, int off)
{
	if (i) {
		skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1];
		return page == frag->page &&
			off == frag->page_offset+frag->size;
	}
	return 0;
}

/*
 * map 2.6 function calls to 2.4 ones defined in net/ipv4/tcp.c
 * and newly exported for our use
 */
#define sk_stream_write_space	tcp_write_space
#define sk_stream_wait_connect(sk,timeo_p)  wait_for_tcp_connect(sk,0,timeo_p)
#define sk_wait_data(sk,timeo_p)	tcp_data_wait(sk,*(timeo_p))

/*
 * from 2.4 code inside tcp_close() in net/ipv4/tcp.c
 * (i.e. version of tcp_wait_close() if it ever existed)
 */
static inline int closing(struct sock * sk)
{
	return ((1 << sk->state) & (TCPF_FIN_WAIT1|TCPF_CLOSING|TCPF_LAST_ACK));
}

static inline void sk_stream_wait_close(struct sock *sk, long timeout)
{
	if (timeout) {
		struct task_struct *tsk = current;
		DECLARE_WAITQUEUE(wait, current);

		add_wait_queue(sk->sleep, &wait);

		do {
			set_current_state(TASK_INTERRUPTIBLE);
			if (!closing(sk))
				break;
			release_sock(sk);
			timeout = schedule_timeout(timeout);
			lock_sock(sk);
		} while (!signal_pending(tsk) && timeout);

		tsk->state = TASK_RUNNING;
		remove_wait_queue(sk->sleep, &wait);
	}
}

/*
 * from 2.6 include/net/sock.h
 */
#define sk_wait_event(__sk, __timeo, __condition)               \
({      int rc;                                                 \
        release_sock(__sk);                                     \
        rc = __condition;                                       \
        if (!rc) {                                              \
                *(__timeo) = schedule_timeout(*(__timeo));      \
        }                                                       \
        lock_sock(__sk);                                        \
        rc = __condition;                                       \
        rc;                                                     \
})

/*
 * From 2.4 net/ipv4/tcp_input.c routine tcp_check_urg().
 */
static inline void sk_send_sigurg(struct sock *sk)
{
	/* Tell the world about our new urgent pointer. */
	if (sk->proc != 0) {
		if (sk->proc > 0)
			kill_proc(sk->proc, SIGURG, 1);
		else
			kill_pg(-sk->proc, SIGURG, 1);
		sk_wake_async(sk, 3, POLL_PRI);
	}
}

#define sock_create_kern	sock_create

/******************************************************************************
 * routing compatibility
 ******************************************************************************/
#define ROUTE_REQ

static inline struct rtattr *
__rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
{
        struct rtattr *rta;
        int size = RTA_LENGTH(attrlen);

        rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
        rta->rta_type = attrtype;
        rta->rta_len = size;
        memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
        return rta;
}

#define __RTA_PUT(skb, attrtype, attrlen) \
({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
                goto rtattr_failure; \
        __rta_reserve(skb, attrtype, attrlen); })

#ifdef CONFIG_TCP_OFFLOAD_MODULE
extern atomic_t tcp_orphan_count_offload;
extern int ip_route_output_flow_offload(struct rtable **rp,
                                        struct flowi *flp,
                                        struct sock *sk, int flags);
#define ip_route_output_flow ip_route_output_flow_offload
#define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count_offload))
#else
#define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count))
#endif /* CONFIG_TCP_OFFLOAD_MODULE */

#define dst_mtu(dst) dst_metric(dst, RTAX_MTU)

/******************************************************************************
 * net data structure compatibility
 ******************************************************************************/
#define tcp_sock tcp_opt
#define inet_sock inet_opt
#define request_sock open_request

#define inet_csk(sk) tcp_sk(sk)
#define inet_csk_destroy_sock(sk) tcp_destroy_sock(sk)
#define inet_csk_route_req(lsk, oreq) tcp_v4_route_req(lsk, oreq)

#define inet_connection_sock tcp_opt
#define icsk_af_ops af_specific
#define icsk_ack ack
#define icsk_pmtu_cookie pmtu_cookie
#define icsk_retransmit_timer retransmit_timer
#define inet_csk_reqsk_queue_removed tcp_synq_removed
#define inet_csk_delete_keepalive_timer tcp_delete_keepalive_timer
#define inet_csk_reqsk_queue_is_full tcp_synq_is_full
#define inet_csk_reqsk_queue_add tcp_acceptq_queue
#define inet_csk_reqsk_queue_added(sk, timeo) tcp_synq_added(sk)

#define __reqsk_free tcp_openreq_fastfree
#define tcp_rsk
#define inet_rsk

#define inet_inherit_port(p_hashinfo, lsk, newsk) tcp_inherit_port(lsk, newsk)
#define t3_inet_put_port(a, sk) tcp_put_port(sk)

#define ACCEPT_QUEUE(sk) (&(tcp_sk(sk)->accept_queue))

#define MSS_CLAMP(tp) ((tp)->mss_clamp)
#define SND_WSCALE(tp) ((tp)->snd_wscale)
#define RCV_WSCALE(tp) ((tp)->rcv_wscale)
#define USER_MSS(tp) ((tp)->user_mss)
#define TS_RECENT_STAMP(tp) ((tp)->ts_recent_stamp)
#define WSCALE_OK(tp) ((tp)->wscale_ok)
#define TSTAMP_OK(tp) ((tp)->tstamp_ok)
#define SACK_OK(tp) ((tp)->sack_ok)

/******************************************************************************
 * netdev compatibility
 ******************************************************************************/
#define __netif_rx_schedule_prep(netdev)	(1)
#define __netif_rx_schedule(netdev)		netif_rx_schedule((netdev))
#define __netif_rx_complete(netdev)		netif_rx_complete((netdev))

#define NETDEV_TX_OK 0          /* driver took care of packet */
#define NETDEV_TX_BUSY 1        /* driver tx path was busy*/
#define NETDEV_TX_LOCKED -1     /* driver tx lock was already taken */

#ifndef SET_NETDEV_DEV
#define	SET_NETDEV_DEV(netdev, pdev)
#endif

#define NETIF_F_LLTX	0
#define NETIF_F_TSO	0

void *netdev_priv(struct net_device *dev);
#ifndef ALLOC_NETDEV
struct net_device *alloc_netdev(int sizeof_priv, const char *mask,
                                       void (*setup)(struct net_device *));
#endif

/******************************************************************************
 * stat compatibility
 ******************************************************************************/

#define LINUX_MIB_TCPABORTONDATA		1
#define LINUX_MIB_TCPABORTONLINGER		2
#define LINUX_MIB_TCPABORTONSYN			3
#define LINUX_MIB_TCPABORTONTIMEOUT		4
#define LINUX_MIB_LISTENOVERFLOWS		5
#define LINUX_MIB_LISTENDROPS			6
#define LINUX_MIB_TCPABORTONCLOSE		7
#define LINUX_MIB_TCPABORTONMEMORY		8

#define	IPSTATS_MIB_OUTNOROUTES 		IpOutNoRoutes

#define	TCP_MIB_ATTEMPTFAILS			TcpAttemptFails
#define	TCP_MIB_ACTIVEOPENS			TcpActiveOpens

static inline void net_inc_stats_bh(int stat)
{
	switch(stat) {
		case LINUX_MIB_TCPABORTONDATA:
			SNMP_INC_STATS_BH(net_statistics, TCPAbortOnData);
			break;
		case LINUX_MIB_TCPABORTONLINGER:
			SNMP_INC_STATS_BH(net_statistics, TCPAbortOnLinger);
			break;
		case LINUX_MIB_TCPABORTONSYN:
			SNMP_INC_STATS_BH(net_statistics, TCPAbortOnSyn);
			break;
		case LINUX_MIB_TCPABORTONTIMEOUT:
			SNMP_INC_STATS_BH(net_statistics, TCPAbortOnTimeout);
			break;
		case LINUX_MIB_LISTENOVERFLOWS:
			SNMP_INC_STATS_BH(net_statistics, ListenOverflows);
			break;
		case LINUX_MIB_LISTENDROPS:
			SNMP_INC_STATS_BH(net_statistics, ListenDrops);
			break;
		case LINUX_MIB_TCPABORTONCLOSE:
			SNMP_INC_STATS_BH(net_statistics, TCPAbortOnClose);
			break;
		case LINUX_MIB_TCPABORTONMEMORY:
			SNMP_INC_STATS_BH(net_statistics, TCPAbortOnMemory);
			break;
	}
}

static inline void net_inc_stats_user(int stat)
{
	switch(stat) {
		case LINUX_MIB_TCPABORTONDATA:
			SNMP_INC_STATS_USER(net_statistics, TCPAbortOnData);
			break;
		case LINUX_MIB_TCPABORTONCLOSE:
			SNMP_INC_STATS_USER(net_statistics, TCPAbortOnClose);
			break;
	}
}

#undef	NET_INC_STATS_USER
#undef	NET_INC_STATS_BH

#define	NET_INC_STATS_BH(stat)			net_inc_stats_bh((stat))
#define	NET_INC_STATS_USER(stat)		net_inc_stats_user((stat))

/******************************************************************************
 * inet_diag
 ******************************************************************************/

enum {
	INET_DIAG_NONE,
	INET_DIAG_MEMINFO,
	INET_DIAG_INFO,
	INET_DIAG_VEGASINFO,
	INET_DIAG_CONG,
};
#define INET_DIAG_MAX INET_DIAG_CONG

/******************************************************************************
 * request_sock
 ******************************************************************************/

struct request_sock_ops {
        int             family;
        int             obj_size;
};

#define rsk_ops class
#define RSK_OPS(rsk) (struct or_calltable *)(rsk)
static inline void t3_init_rsk_ops(struct proto *t3_tcp_prot,
                                   struct request_sock_ops *t3_tcp_ops,
                                   struct proto *tcp_prot)
{}

static inline struct open_request *reqsk_alloc(struct request_sock_ops *rsk)
{
        struct open_request *oreq = tcp_openreq_alloc();

        if (oreq)
                oreq->class = (struct or_calltable *)rsk;

        return oreq;
}

static inline void t3_set_req_addr(struct open_request *oreq,
                                   __u32 local_ip, __u32 peer_ip)
{
        oreq->af.v4_req.loc_addr = local_ip;
        oreq->af.v4_req.rmt_addr = peer_ip;
}

static inline void t3_set_req_opt(struct open_request *oreq,
                                  struct ip_options *ip_opt)
{
}

static inline void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
{
        __sk_dst_set(sk, dst);
        tcp_v4_setup_caps(sk, dst);
}

static inline void setup_timer(struct timer_list * timer,
                                void (*function)(unsigned long),
                                unsigned long data)
{
        timer->function = function;
        timer->data = data;
        init_timer(timer);
}

extern int prepare_tom_for_offload(void);

/******************************************************************************
 * memory management compatibility
 ******************************************************************************/
#define	__GFP_NOFAIL	0

#ifndef KZALLOC
static inline void *kzalloc(size_t size, int flags)
{
	void *ret = kmalloc(size, flags);
	if (ret)
		memset(ret, 0, size);
	return ret;
}
#endif

/* from include/linux/libata-compat.h */
static inline void *kcalloc(size_t nmemb, size_t size, int flags)
{
	size_t total = nmemb * size;
	void *mem = kmalloc(total, flags);
	if (mem)
		memset(mem, 0, total);
	return mem;
}

#define set_page_dirty_lock	set_page_dirty

/******************************************************************************
 * timer compatibility
 ******************************************************************************/
unsigned int jiffies_to_msecs(const unsigned long j);
unsigned long msecs_to_jiffies(const unsigned int m);
signed long schedule_timeout_interruptible(signed long timeout);
signed long schedule_timeout_uninterruptible(signed long timeout);
void msleep(unsigned int msecs);
unsigned long msleep_interruptible(unsigned int msecs);

/******************************************************************************
 * work queue compatibility
 ******************************************************************************/
#include <linux/workqueue.h>
struct workqueue_struct * create_singlethread_workqueue(const char *name);
void destroy_workqueue(struct workqueue_struct *wq);
int queue_work(struct workqueue_struct *cwq, struct work_struct *work);
int queue_delayed_work(struct workqueue_struct *wq,
                        struct work_struct *work, unsigned long delay);
void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
                                       struct work_struct *work);

/******************************************************************************
 * SMP compatibility
 ******************************************************************************/
static inline int num_online_cpus(void)
{
	return smp_num_cpus;
}

int generic_fls(int x);

#ifndef IF_MII
/******************************************************************************
 * MII compatibility
 ******************************************************************************/
static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
{
	return (struct mii_ioctl_data *) &rq->ifr_ifru;
} 
#endif

/******************************************************************************
 * atomic ops
 ******************************************************************************/

#if defined(CONFIG_T3_ZCOPY_SENDMSG) || defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
# define t3_ptep_set_wrprotect(mm, address, ptep) ptep_set_wrprotect(ptep)
#endif

#if defined(NETDMA_IN_KERNEL) && !defined(IOAT_SOCK)
if defined(NETDMA_IN_KERNEL) && !defined(IOAT_SOCK)
static inline void tom_eat_skb(struct sock *sk, struct sk_buff *skb,
			      int copied_early)
{
	skb->dst = NULL;
	sk_eat_skb(sk, skb, copied_early);
}

#else
static inline void tom_eat_skb(struct sock *sk, struct sk_buff *skb,
			      int copied_early)
{
	skb->dst = NULL;
	sk_eat_skb(sk, skb);
}
#endif

#define DECLARE_TASK_FUNC(task, task_param) \
	static void task(void *task_param)

#define T3_INIT_WORK INIT_WORK

#define WORK2TOMDATA(task_param, task) task_param

#define T3_DECLARE_WORK(task, func, data) \
	DECLARE_WORK(task, func, data)

#if defined(CONFIG_T3_ZCOPY_SENDMSG) || defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)

/* Older kernels don't have a PUD; if that's the case, simply fold that level.
 */
#ifndef PUD_SIZE
# define pud_t			pgd_t
# define pud_offset(pgd, addr)	(pgd)
# define pud_none(pud)		0
# define pud_bad(pud)		0
# define pud_present(pud)	0
#endif

/* Unfortunately, flush_tlb_range() is not available on all platforms and 
 * configurations and we must fall back to an implementation based on
 * flush_tlb_page(). Good thing that tlb flushing is in the exception path
 * only.
 */ 
static inline void _t3_flush_tlb_range(struct vm_area_struct *vma,
				       unsigned long start, unsigned long end)
{
	for (; start < end; start += PAGE_SIZE)
		flush_tlb_page(vma, start);
}

#if defined(CONFIG_X86)
# if !defined(CONFIG_SMP)
#  define t3_flush_tlb_range flush_tlb_range
# else
#  define t3_flush_tlb_range _t3_flush_tlb_range
# endif
#elif defined(CONFIG_PPC)
# define t3_flush_tlb_range _t3_flush_tlb_range
#else
# define t3_flush_tlb_range flush_tlb_range
#endif

#if defined(CONFIG_T3_ZCOPY_HUGEPAGES)
static __inline__ int zcopy_vma(struct vm_area_struct *vma) {
	return !(vma->vm_flags & VM_SHARED);
}
#else
static __inline__ int zcopy_vma(struct vm_area_struct *vma) {
	return !((vma->vm_flags & VM_SHARED) || is_vm_hugetlb_page(vma));
}
#endif

#if defined(CONFIG_T3_ZCOPY_HUGEPAGES) && defined(CONFIG_HUGETLB_PAGE)
#if defined(CONFIG_IA64)
static __inline__ pte_t *
t3_huge_pte_offset (struct mm_struct *mm, unsigned long addr)
{
        unsigned long taddr = htlbpage_to_page(addr);
        pgd_t *pgd;
        pmd_t *pmd;
        pte_t *pte = NULL;

        pgd = pgd_offset(mm, taddr);
        if (pgd_present(*pgd)) {
                pmd = pmd_offset(pgd, taddr);
                if (pmd_present(*pmd))
                        pte = pte_offset(pmd, taddr);
        }

        return pte;
}
#else
static __inline__ pte_t *t3_huge_pte_offset(struct mm_struct *mm, unsigned long addr)
{
	return pte_offset(mm, addr);
}
#endif
#endif
#endif /* ZCOPY_SENDMSG */

#define T3_NET_INC_STATS_BH(net, field) NET_INC_STATS_BH(field)
#define T3_TCP_INC_STATS_BH(net, field) TCP_INC_STATS_BH(field)
#define T3_TCP_INC_STATS(net, field)    TCP_INC_STATS(field)
#define T3_NET_INC_STATS_USER(net, field) NET_INC_STATS_USER(field)
#define t3_type_compat int

/******************************************************************************
 * sysctl compatibility
 ******************************************************************************/
static inline void tom_sysctl_set_de(ctl_table *tbl)
{
	tbl->de = NULL;
}
#define tom_register_sysctl_table register_sysctl_table

/******************************************************************************
 * PCI compatibility
 ******************************************************************************/
static inline int t3_pci_dma_mapping_error(struct pci_dev *pdev,
					   dma_addr_t dma_addr)
{
	return dma_addr == 0;
}
#endif /* __TOM_COMPAT_2_4_H */