/*
 * Copyright (c) 2003-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 __LINUX_2_4_COMPAT_H__
#define __LINUX_2_4_COMPAT_H__

#include <linux/pci.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>
#include <linux/filter.h>
#include <linux/cache.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <net/sock.h>
#include <net/snmp.h>
#include <net/ip.h>
#include <asm/atomic.h>
#include <asm/semaphore.h>
#include <asm/bitops.h>
#include <asm/io.h>

/******************************************************************************
 * directives
 ******************************************************************************/
#define	__read_mostly
#define	__user
#define	__iomem

/******************************************************************************
 * 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

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

#ifndef spin_trylock_irqsave
#define _spin_trylock	spin_trylock
#define spin_trylock_irqsave(lock, flags) \
({ \
	local_irq_save(flags); \
	_spin_trylock(lock) ? \
	1 : ({ local_irq_restore(flags); 0; }); \
})
#endif

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

/*
 * 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;

int atomic_add_return(int i, atomic_t *v);

#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;
};

void tcp_v4_setup_caps(struct sock *sk, struct dst_entry *dst);

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

/******************************************************************************
 * 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 */
};

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:
        	case SOCK_TIMESTAMP:
        	case SOCK_QUEUE_SHRUNK:
		default:
			/* XXX */
			printk("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:
        	case SOCK_TIMESTAMP:
        	case SOCK_QUEUE_SHRUNK:
		default:
			/* XXX */
			printk("sock_set_flag_val: 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);
}

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

/*
 * 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

/******************************************************************************
 * 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); })

#define INET_DIAG_MAX INET_DIAG_CONG

#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 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 inet_put_port(a, sk) tcp_put_port(sk)

#define ACCEPT_QUEUE(sk) (&(tcp_sk(sk)->accept_queue))
#define ACCEPT_QUEUE_TAIL(sk) (&(tcp_sk(sk)->accept_queue_tail))
#define LISTEN_OPT(sk) (&(tcp_sk(sk)->listen_opt))

#define PACKETS_OUT(tcp_sock) ((tcp_sock)->packets_out)
#define LEFT_OUT(tcp_sock) ((tcp_sock)->left_out)
#define RETRANS_OUT(tcp_sock) ((tcp_sock)->retrans_out)

#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 NUM_SACKS(tp) ((tp)->num_sacks)
#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)

#define forward_skb_hint ucopy.prequeue.next
#define fastpath_skb_hint ucopy.prequeue.prev


/******************************************************************************
 * netdev compatibility
 ******************************************************************************/
static inline int __netif_rx_schedule_prep(struct net_device *dev)
{
	return !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
}

#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

#ifndef NETIF_F_LLTX
#define NETIF_F_LLTX	0
#endif
#ifndef NETIF_F_TSO
#define NETIF_F_TSO	0
#define NETIF_F_TSO_FAKE
#endif

#define NETDEV_ALIGN            32
#define NETDEV_ALIGN_CONST      (NETDEV_ALIGN - 1)

static inline void *netdev_priv(struct net_device *dev)
{
        return (char *)dev + ((sizeof(struct net_device)
                                        + NETDEV_ALIGN_CONST)
                                & ~NETDEV_ALIGN_CONST);
}

#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(int stat)
{
	switch(stat) {
		case LINUX_MIB_TCPABORTONDATA:
			SNMP_INC_STATS(net_statistics, TCPAbortOnData);
			break;
		case LINUX_MIB_TCPABORTONLINGER:
			SNMP_INC_STATS(net_statistics, TCPAbortOnLinger);
			break;
		case LINUX_MIB_TCPABORTONSYN:
			SNMP_INC_STATS(net_statistics, TCPAbortOnSyn);
			break;
		case LINUX_MIB_TCPABORTONTIMEOUT:
			SNMP_INC_STATS(net_statistics, TCPAbortOnTimeout);
			break;
		case LINUX_MIB_LISTENOVERFLOWS:
			SNMP_INC_STATS(net_statistics, ListenOverflows);
			break;
		case LINUX_MIB_LISTENDROPS:
			SNMP_INC_STATS(net_statistics, ListenDrops);
			break;
		case LINUX_MIB_TCPABORTONCLOSE:
			SNMP_INC_STATS(net_statistics, TCPAbortOnClose);
			break;
		case LINUX_MIB_TCPABORTONMEMORY:
			SNMP_INC_STATS(net_statistics, TCPAbortOnMemory);
			break;
	}
}

#if XXX
#undef	NET_INC_STATS_USER
#undef	NET_INC_STATS_BH

#define	NET_INC_STATS_BH(stat)			net_inc_stats((stat))
#define	NET_INC_STATS_USER(stat)		net_inc_stats((stat))
#endif

struct request_sock_ops {
        int             family;
        int             obj_size;
};

/* Inet diag stuff. Added for compilation only */
enum {
        INET_DIAG_NONE,
        INET_DIAG_MEMINFO,
        INET_DIAG_INFO,
        INET_DIAG_VEGASINFO,
        INET_DIAG_CONG,
};

static inline void t3_init_rsk_ops(struct proto *t3_tcp_prot,
                                   struct request_sock_ops *t3_tcp_ops,
                                   struct proto *tcp_prot)
{}

#ifdef XXX
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)
{
}
#endif

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);
}

static inline int synq_empty(struct sock *sk)
{
	return skb_queue_empty(&tcp_sk(sk)->ucopy.prequeue);
}

static inline void reset_synq(struct tcp_sock *tp)
{
	skb_queue_head_init(&tp->ucopy.prequeue);
}

static inline void reset_wr_list(struct tcp_sock *tp)
{
	skb_queue_head_init(&tp->ucopy.prequeue);
}

static inline int wr_list_empty(struct tcp_sock *tp)
{
	return (skb_queue_empty(&tp->ucopy.prequeue));
}

/*
 * Add a WR to a socket's list of pending WRs.  This is a singly-linked list
 */
static inline void enqueue_wr(struct tcp_sock *tp, struct sk_buff *skb)
{
        struct sk_buff *tail = (struct sk_buff *)tp->ucopy.iov;

        skb->dev = NULL;
        /*
         *  We want to take an extra reference since both us and the driver
         *  need to free the packet before it's really freed.  We know there's
         * just one user currently so we use atomic_set rather than skb_get
         * to avoid the atomic op.
         */
        atomic_set(&skb->users, 2);

        if (wr_list_empty(tp))
                tp->ucopy.prequeue.next = skb;
        else
                tail->dev = (void *)skb;
        tp->ucopy.iov = (void *)skb;

}


/*
 * Return the first pending WR without removing it from the list.
 */
static inline struct sk_buff *peek_wr(struct tcp_sock *tp)
{
        if (unlikely(wr_list_empty(tp)))
                return NULL;
        return (tp->ucopy.prequeue.next);
}

/*
 * Dequeue and return the first unacknowledged's WR on a socket's pending list.
 */
static inline struct sk_buff *dequeue_wr(struct tcp_sock *tp)
{
        struct sk_buff *skb = tp->ucopy.prequeue.next;

        if (unlikely(wr_list_empty(tp)))
                        return NULL;

        if (!skb->dev)
                tp->ucopy.prequeue.next = tp->ucopy.prequeue.prev;
        else
                tp->ucopy.prequeue.next = (void *)skb->dev;

        skb->dev = NULL;
        return skb;
}

extern int prepare_tom_for_offload(void);

/* these are defined to nothing since 2.4 interrupt handlers are voids */
#define	IRQ_NONE
#define	IRQ_HANDLED
#define	IRQ_RETVAL(x)

/******************************************************************************
 * DMA compatibility
 ******************************************************************************/
#define DMA_64BIT_MASK  0xffffffffffffffffULL
#define DMA_48BIT_MASK  0x0000ffffffffffffULL
#define DMA_40BIT_MASK  0x000000ffffffffffULL
#define DMA_39BIT_MASK  0x0000007fffffffffULL
#define DMA_32BIT_MASK  0x00000000ffffffffULL
#define DMA_31BIT_MASK  0x000000007fffffffULL
#define DMA_30BIT_MASK  0x000000003fffffffULL
#define DMA_29BIT_MASK  0x000000001fffffffULL
#define DMA_28BIT_MASK  0x000000000fffffffULL
#define DMA_24BIT_MASK  0x0000000000ffffffULL

/******************************************************************************
 * PHY compatibility
 ******************************************************************************/
#define BMCR_SPEED1000          0x0040  /* MSB of Speed (1000)         */

#define MII_CTRL1000        0x09        /* 1000BASE-T control          */

#define ADVERTISE_1000XFULL     0x0020  /* Try for 1000BASE-X full-duplex */
#define ADVERTISE_1000XHALF     0x0040  /* Try for 1000BASE-X half-duplex */
#define ADVERTISE_1000XPAUSE	0x0080	/* Try for 1000BASE-X pause    */
#define ADVERTISE_1000XPSE_ASYM	0x0100	/* Try for 1000BASE-X asym pause */
#define ADVERTISE_PAUSE_CAP     0x0400  /* Try for pause               */
#define ADVERTISE_PAUSE_ASYM    0x0800  /* Try for asymetric pause     */

/* 1000BASE-T Control register */
#define ADVERTISE_1000FULL      0x0200  /* Advertise 1000BASE-T full duplex */
#define ADVERTISE_1000HALF      0x0100  /* Advertise 1000BASE-T half duplex */

#define ADVERTISED_Pause                (1 << 13)
#define ADVERTISED_Asym_Pause           (1 << 14)

/******************************************************************************
 * PCI compatibility
 ******************************************************************************/
int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask);
static inline int pci_dma_mapping_error(dma_addr_t addr)
{
	return (addr == 0);
}

#define PCI_VPD_ADDR            2       /* Address to access (15 bits!) */
#define  PCI_VPD_ADDR_MASK      0x7fff  /* Address mask */
#define  PCI_VPD_ADDR_F         0x8000  /* Write 0, 1 indicates completion */
#define PCI_VPD_DATA            4       /* 32-bits of data returned here */

/* PCI Express capability registers */
#define PCI_EXP_FLAGS           2       /* Capabilities register */
#define PCI_EXP_FLAGS_VERS      0x000f  /* Capability version */
#define PCI_EXP_FLAGS_TYPE      0x00f0  /* Device/Port type */
#define  PCI_EXP_TYPE_ENDPOINT  0x0     /* Express Endpoint */
#define  PCI_EXP_TYPE_LEG_END   0x1     /* Legacy Endpoint */
#define  PCI_EXP_TYPE_ROOT_PORT 0x4     /* Root Port */
#define  PCI_EXP_TYPE_UPSTREAM  0x5     /* Upstream Port */
#define  PCI_EXP_TYPE_DOWNSTREAM 0x6    /* Downstream Port */
#define  PCI_EXP_TYPE_PCI_BRIDGE 0x7    /* PCI/PCI-X Bridge */
#define PCI_EXP_FLAGS_SLOT      0x0100  /* Slot implemented */
#define PCI_EXP_FLAGS_IRQ       0x3e00  /* Interrupt message number */
#define PCI_EXP_DEVCAP          4       /* Device capabilities */
#define  PCI_EXP_DEVCAP_PAYLOAD 0x07    /* Max_Payload_Size */
#define  PCI_EXP_DEVCAP_PHANTOM 0x18    /* Phantom functions */
#define  PCI_EXP_DEVCAP_EXT_TAG 0x20    /* Extended tags */
#define  PCI_EXP_DEVCAP_L0S     0x1c0   /* L0s Acceptable Latency */
#define  PCI_EXP_DEVCAP_L1      0xe00   /* L1 Acceptable Latency */
#define  PCI_EXP_DEVCAP_ATN_BUT 0x1000  /* Attention Button Present */
#define  PCI_EXP_DEVCAP_ATN_IND 0x2000  /* Attention Indicator Present */
#define  PCI_EXP_DEVCAP_PWR_IND 0x4000  /* Power Indicator Present */
#define  PCI_EXP_DEVCAP_PWR_VAL 0x3fc0000 /* Slot Power Limit Value */
#define  PCI_EXP_DEVCAP_PWR_SCL 0xc000000 /* Slot Power Limit Scale */
#define PCI_EXP_DEVCTL          8       /* Device Control */
#define  PCI_EXP_DEVCTL_CERE    0x0001  /* Correctable Error Reporting En. */
#define  PCI_EXP_DEVCTL_NFERE   0x0002  /* Non-Fatal Error Reporting Enable */
#define  PCI_EXP_DEVCTL_FERE    0x0004  /* Fatal Error Reporting Enable */
#define  PCI_EXP_DEVCTL_URRE    0x0008  /* Unsupported Request Reporting En. */
#define  PCI_EXP_DEVCTL_RELAX_EN 0x0010 /* Enable relaxed ordering */
#define  PCI_EXP_DEVCTL_PAYLOAD 0x00e0  /* Max_Payload_Size */
#define  PCI_EXP_DEVCTL_EXT_TAG 0x0100  /* Extended Tag Field Enable */
#define  PCI_EXP_DEVCTL_PHANTOM 0x0200  /* Phantom Functions Enable */
#define  PCI_EXP_DEVCTL_AUX_PME 0x0400  /* Auxiliary Power PM Enable */
#define  PCI_EXP_DEVCTL_NOSNOOP_EN 0x0800  /* Enable No Snoop */
#define  PCI_EXP_DEVCTL_READRQ  0x7000  /* Max_Read_Request_Size */
#define PCI_EXP_DEVSTA          10      /* Device Status */
#define  PCI_EXP_DEVSTA_CED     0x01    /* Correctable Error Detected */
#define  PCI_EXP_DEVSTA_NFED    0x02    /* Non-Fatal Error Detected */
#define  PCI_EXP_DEVSTA_FED     0x04    /* Fatal Error Detected */
#define  PCI_EXP_DEVSTA_URD     0x08    /* Unsupported Request Detected */
#define  PCI_EXP_DEVSTA_AUXPD   0x10    /* AUX Power Detected */
#define  PCI_EXP_DEVSTA_TRPND   0x20    /* Transactions Pending */
#define PCI_EXP_LNKCAP          12      /* Link Capabilities */
#define PCI_EXP_LNKCTL          16      /* Link Control */
#define PCI_EXP_LNKSTA          18      /* Link Status */
#define PCI_EXP_SLTCAP          20      /* Slot Capabilities */
#define PCI_EXP_SLTCTL          24      /* Slot Control */
#define PCI_EXP_SLTSTA          26      /* Slot Status */
#define PCI_EXP_RTCTL           28      /* Root Control */
#define  PCI_EXP_RTCTL_SECEE    0x01    /* System Error on Correctable Error */
#define  PCI_EXP_RTCTL_SENFEE   0x02    /* System Error on Non-Fatal Error */
#define  PCI_EXP_RTCTL_SEFEE    0x04    /* System Error on Fatal Error */
#define  PCI_EXP_RTCTL_PMEIE    0x08    /* PME Interrupt Enable */
#define  PCI_EXP_RTCTL_CRSSVE   0x10    /* CRS Software Visibility Enable */
#define PCI_EXP_RTCAP           30      /* Root Capabilities */
#define PCI_EXP_RTSTA           32      /* Root Status */

#define  PCI_CAP_ID_EXP         0x10    /* PCI Express */

struct msix_entry {
        u16     vector; /* kernel uses to write allocated vector */
        u16     entry;  /* driver uses to specify entry, OS writes */
};

int pci_enable_msi(struct pci_dev* dev);
int pci_disable_msi(struct pci_dev* dev);
int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec);
int pci_disable_msix(struct pci_dev* dev);

inline int t3_os_pci_save_state(adapter_t *adapter);
inline int t3_os_pci_restore_state(adapter_t *adapter);

#define	pci_dma_sync_single_for_cpu	pci_dma_sync_single
#define	pci_dma_sync_single_for_device	pci_dma_sync_single


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

void *kzalloc(size_t size, gfp_t flags);
void *kcalloc(size_t n, size_t size, gfp_t flags);

/******************************************************************************
 * 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);

/******************************************************************************
 * 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

#endif 	/* __LINUX_2_4_COMPAT_H__ */