| /* |
| * This file is part of the Chelsio T3 Ethernet driver. |
| * |
| * Copyright (C) 2003-2009 Chelsio Communications. 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 __CXGB3_COMPAT_H |
| #define __CXGB3_COMPAT_H |
| |
| #include <linux/version.h> |
| #include "common.h" |
| #include <linux/pci.h> |
| |
| #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21) |
| #include <asm/kdebug.h> |
| |
| #ifdef RHEL_RELEASE_CODE |
| |
| #if RHEL_RELEASE_CODE <= RHEL_RELEASE_VERSION(4, 8) |
| #define unregister_die_notifier(a) |
| #define register_die_notifier(a) |
| #endif |
| |
| #else |
| |
| #define unregister_die_notifier(a) |
| #define register_die_notifier(a) |
| |
| #endif |
| |
| #ifdef SLE_VERSION |
| |
| #if SLE_VERSION_CODE <= SLE_VERSION(10,3,0) |
| #define unregister_die_notifier(a) |
| #define register_die_notifier(a) |
| #endif |
| |
| #endif |
| |
| #else |
| #include <linux/kdebug.h> |
| #endif |
| |
| /* XXX Verify OS version */ |
| #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13) && \ |
| LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,5) |
| |
| #if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,5) |
| |
| struct msix_entry { |
| u16 vector; /* kernel uses to write allocated vector */ |
| u16 entry; /* driver uses to specify entry, OS writes */ |
| }; |
| |
| static inline void pci_disable_msi(struct pci_dev *dev) |
| {} |
| |
| static inline int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, |
| int nvec) |
| { |
| return -1; |
| } |
| |
| static inline void pci_disable_msix(struct pci_dev* dev) |
| {} |
| |
| static inline struct mii_ioctl_data *if_mii(struct ifreq *rq) |
| |
| { |
| return (struct mii_ioctl_data *) &rq->ifr_ifru; |
| } |
| |
| #define _spin_trylock spin_trylock |
| |
| #endif /* KERNEL_VERSION(2.6.5) */ |
| |
| #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); \ |
| }) |
| |
| #elif defined(CONFIG_PPC64) |
| static __inline__ int atomic_add_return(int a, atomic_t *v) |
| { |
| int t; |
| |
| __asm__ __volatile__( |
| EIEIO_ON_SMP |
| "1: lwarx %0,0,%2 # atomic_add_return\n\ |
| add %0,%1,%0\n\ |
| stwcx. %0,0,%2\n\ |
| bne- 1b" |
| ISYNC_ON_SMP |
| : "=&r" (t) |
| : "r" (a), "r" (&v->counter) |
| : "cc", "memory"); |
| |
| return t; |
| } |
| |
| #elif defined(CONFIG_PPC) |
| static __inline__ int atomic_add_return(int a, atomic_t *v) |
| { |
| int t; |
| |
| __asm__ __volatile__( |
| "1: lwarx %0,0,%2 # atomic_add_return\n\ |
| add %0,%1,%0\n" |
| PPC405_ERR77(0,%2) |
| " stwcx. %0,0,%2 \n\ |
| bne- 1b" |
| SMP_ISYNC |
| : "=&r" (t) |
| : "r" (a), "r" (&v->counter) |
| : "cc", "memory"); |
| |
| return t; |
| } |
| #endif |
| #endif /* ATOMIC_ADD_RETURN */ |
| |
| #ifndef SPIN_TRYLOCK_IRQSAVE |
| #define spin_trylock_irqsave(lock, flags) \ |
| ({ \ |
| local_irq_save(flags); \ |
| _spin_trylock(lock) ? \ |
| 1 : ({ local_irq_restore(flags); 0; }); \ |
| }) |
| #endif |
| |
| |
| #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11) |
| static inline int t3_os_pci_save_state(struct adapter *adapter) |
| { |
| return pci_save_state(adapter->pdev, adapter->t3_config_space); |
| } |
| |
| static inline int t3_os_pci_restore_state(struct adapter *adapter) |
| { |
| return pci_restore_state(adapter->pdev, adapter->t3_config_space); |
| } |
| |
| static |
| inline void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq, |
| struct work_struct *work) |
| { |
| while (!cancel_delayed_work(work)) |
| flush_workqueue(wq); |
| } |
| |
| #else |
| static inline int t3_os_pci_save_state(adapter_t *adapter) |
| { |
| return pci_save_state(adapter->pdev); |
| } |
| |
| static inline int t3_os_pci_restore_state(adapter_t *adapter) |
| { |
| return pci_restore_state(adapter->pdev); |
| } |
| #endif |
| |
| static inline int __netif_rx_schedule_prep(struct net_device *dev) |
| { |
| return !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state); |
| } |
| |
| #ifndef CONFIG_DEBUG_FS |
| #include <linux/err.h> |
| /* Adapted from debugfs.h */ |
| static inline struct dentry *debugfs_create_dir(const char *name, |
| struct dentry *parent) |
| { |
| return ERR_PTR(-ENODEV); |
| } |
| |
| static inline void debugfs_remove(struct dentry *dentry) |
| {} |
| #else |
| #include <linux/debugfs.h> |
| #endif |
| |
| 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); |
| } |
| |
| #define DEFINE_MUTEX DECLARE_MUTEX |
| #define mutex_lock down |
| #define mutex_unlock up |
| |
| #undef DEFINE_RWLOCK /* broken RH4u3 definition, rw_lock_t does not exist */ |
| #define DEFINE_RWLOCK(x) rwlock_t x = RW_LOCK_UNLOCKED |
| |
| #define gfp_t unsigned |
| |
| /* 2.6.14 and above */ |
| #elif LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13) |
| #include <linux/debugfs.h> |
| |
| static inline int t3_os_pci_save_state(adapter_t *adapter) |
| { |
| return pci_save_state(adapter->pdev); |
| } |
| |
| static inline int t3_os_pci_restore_state(adapter_t *adapter) |
| { |
| return pci_restore_state(adapter->pdev); |
| } |
| |
| #endif /* LINUX_VERSION_CODE */ |
| |
| #if !defined(NETEVENT) |
| struct notifier_block; |
| |
| static inline void register_netevent_notifier(struct notifier_block *nb) |
| {} |
| |
| static inline void unregister_netevent_notifier(struct notifier_block *nb) |
| {} |
| |
| #if defined(CONFIG_TCP_OFFLOAD_MODULE) && defined(CONFIG_X86) |
| #define OFLD_USE_KPROBES |
| #endif |
| |
| #else |
| extern int netdev_nit; |
| #endif |
| |
| |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) |
| |
| typedef irqreturn_t (*intr_handler_t)(int, void *, struct pt_regs *); |
| #define DECLARE_INTR_HANDLER(handler, irq, cookie, regs) \ |
| static irqreturn_t handler(int irq, void *cookie, struct pt_regs *regs) |
| |
| intr_handler_t t3_intr_handler(struct adapter *adap, int polling); |
| static inline void t3_poll_handler(struct adapter *adapter, |
| struct sge_qset *qs) |
| { |
| t3_intr_handler(adapter, qs->rspq.flags & USING_POLLING) (0, |
| (adapter->flags & USING_MSIX) ? (void *)qs : (void *)adapter, |
| NULL); |
| } |
| |
| #define CHECKSUM_PARTIAL CHECKSUM_HW |
| #define CHECKSUM_COMPLETE CHECKSUM_HW |
| |
| #ifndef I_PRIVATE |
| #define i_private u.generic_ip |
| #endif |
| |
| #else /* 2.6.19 */ |
| typedef irqreturn_t (*intr_handler_t)(int, void *); |
| #define DECLARE_INTR_HANDLER(handler, irq, cookie, regs) \ |
| static irqreturn_t handler(int irq, void *cookie) |
| |
| intr_handler_t t3_intr_handler(struct adapter *adap, int polling); |
| static inline void t3_poll_handler(struct adapter *adapter, |
| struct sge_qset *qs) |
| { |
| t3_intr_handler(adapter, qs->rspq.flags & USING_POLLING) (0, |
| (adapter->flags & USING_MSIX) ? (void *)qs : (void *)adapter); |
| } |
| |
| #endif /* 2.6.19 */ |
| |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) |
| #define DECLARE_TASK_FUNC(task, task_param) \ |
| static void task(void *task_param) |
| |
| #define WORK2ADAP(task_param, task) task_param |
| #define DELWORK2ADAP(task_param, task) task_param |
| #define WORK2T3CDATA(task_param, task) task_param |
| |
| #define delayed_work work_struct |
| |
| #define T3_INIT_WORK INIT_WORK |
| #define T3_INIT_DELAYED_WORK INIT_WORK |
| |
| #else /* 2.6.20 */ |
| |
| #define DECLARE_TASK_FUNC(task, task_param) \ |
| static void task(struct work_struct *task_param) |
| |
| #define WORK2ADAP(task_param, task) \ |
| container_of(task_param, struct adapter, task) |
| |
| #define DELWORK2ADAP(task_param, task) \ |
| container_of(task_param, struct adapter, task.work) |
| |
| #define WORK2T3CDATA(task_param, task) \ |
| container_of(task_param, struct t3c_data, task) |
| |
| #define T3_INIT_WORK(task_handler, task, adapter) \ |
| INIT_WORK(task_handler, task) |
| |
| #define T3_INIT_DELAYED_WORK(task_handler, task, adapter) \ |
| INIT_DELAYED_WORK(task_handler, task) |
| |
| #endif /* 2.6.20 */ |
| |
| #if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE) |
| #include <linux/firmware.h> |
| #else |
| struct firmware { |
| size_t size; |
| u8 *data; |
| }; |
| |
| struct device; |
| |
| static inline int request_firmware(const struct firmware **firmware_p, |
| char *name, |
| struct device *device) |
| { |
| printk(KERN_WARNING |
| "FW_LOADER not set in this kernel. FW upgrade aborted.\n"); |
| return -1; |
| } |
| |
| static inline void release_firmware(const struct firmware *fw) |
| {} |
| #endif /* FW_LOADER */ |
| |
| #if !defined(RTNL_TRYLOCK) |
| #include <linux/rtnetlink.h> |
| static inline int rtnl_trylock(void) |
| { |
| return !rtnl_shlock_nowait(); |
| } |
| #endif /* RTNL_TRYLOCK */ |
| |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,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 /* KZALLOC */ |
| #endif |
| |
| #ifndef GSO_SIZE |
| #define gso_size tso_size |
| #endif /* GSO_SIZE */ |
| |
| #ifndef NIPQUAD_FMT |
| #define NIPQUAD_FMT "%u.%u.%u.%u" |
| #endif |
| |
| /* sysfs compatibility */ |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21) |
| |
| #define to_net_dev(class) container_of(class, struct net_device, class_dev) |
| |
| #define cxgb3_compat_device class_device |
| |
| #define CXGB3_SHOW_FUNC(func, d, attr, buf) \ |
| static ssize_t func(struct cxgb3_compat_device *d, \ |
| char *buf) \ |
| |
| #define CXGB3_STORE_FUNC(func, d, attr, buf, len) \ |
| static ssize_t func(struct cxgb3_compat_device *d, \ |
| const char *buf, \ |
| size_t len) |
| |
| #ifndef __ATTR |
| #define __ATTR(_name,_mode,_show,_store) { \ |
| .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE }, \ |
| .show = _show, \ |
| .store = _store, \ |
| } |
| #endif |
| |
| #define CXGB3_DEVICE_ATTR(_name,_mode,_show,_store) \ |
| struct class_device_attribute dev_attr_##_name = \ |
| __ATTR(_name,_mode,_show,_store) |
| |
| #ifndef LINUX_2_4 |
| static inline struct kobject *net2kobj(struct net_device *dev) |
| { |
| return &dev->class_dev.kobj; |
| } |
| #endif |
| |
| #else /* sysfs compatibility */ |
| |
| #define cxgb3_compat_device device |
| |
| #define CXGB3_SHOW_FUNC(func, d, attr, buf) \ |
| static ssize_t func(struct cxgb3_compat_device *d, \ |
| struct device_attribute *attr, \ |
| char *buf) \ |
| |
| #define CXGB3_STORE_FUNC(func, d, attr, buf, len) \ |
| static ssize_t func(struct cxgb3_compat_device *d, \ |
| struct device_attribute *attr, \ |
| const char *buf, \ |
| size_t len) |
| |
| #define CXGB3_DEVICE_ATTR DEVICE_ATTR |
| |
| static inline struct kobject *net2kobj(struct net_device *dev) |
| { |
| return &dev->dev.kobj; |
| } |
| |
| #endif /* sysfs compatibility */ |
| |
| #if !defined(IRQF) |
| #define IRQF_SHARED SA_SHIRQ |
| #endif /* IRQF */ |
| |
| #if !defined(VLANGRP) |
| #include <linux/if_vlan.h> |
| static inline struct net_device *vlan_group_get_device(struct vlan_group *vg, |
| int vlan_id) |
| { |
| return vg->vlan_devices[vlan_id]; |
| } |
| #endif /* VLANGRP */ |
| |
| #if !defined(for_each_netdev) |
| #define for_each_netdev(d) \ |
| for (d = dev_base; d; d = d->next) |
| #endif |
| |
| #include <linux/ip.h> |
| |
| #if !defined(NEW_SKB_COPY) |
| static inline void skb_copy_from_linear_data(const struct sk_buff *skb, |
| void *to, |
| const unsigned int len) |
| { |
| memcpy(to, skb->data, len); |
| } |
| |
| static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb, |
| const int offset, void *to, |
| const unsigned int len) |
| { |
| memcpy(to, skb->data + offset, len); |
| } |
| |
| static inline void skb_copy_to_linear_data(struct sk_buff *skb, |
| const void *from, |
| const unsigned int len) |
| { |
| memcpy(skb->data, from, len); |
| } |
| |
| static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb, |
| const int offset, |
| const void *from, |
| const unsigned int len) |
| { |
| memcpy(skb->data + offset, from, len); |
| } |
| |
| #endif |
| |
| #if defined(NEW_SKB_OFFSET) |
| static inline void cxgb3_set_skb_header(struct sk_buff *skb, |
| struct iphdr *ip_hdr, |
| int offset) |
| { |
| skb_set_network_header(skb, offset); |
| } |
| |
| #else /* NEW_SKB_OFFSET */ |
| static inline int skb_network_offset(struct sk_buff *skb) |
| { |
| return skb->nh.raw - skb->data; |
| } |
| |
| static inline unsigned char *skb_transport_header(const struct sk_buff *skb) |
| { |
| return skb->h.raw; |
| } |
| |
| #if !defined(T3_SKB_TRANSPORT_OFFSET) |
| static inline int skb_transport_offset(const struct sk_buff *skb) |
| { |
| return skb->h.raw - skb->data; |
| } |
| #endif |
| |
| #if !defined(T3_IP_HDR) |
| static inline struct iphdr *ip_hdr(const struct sk_buff *skb) |
| { |
| return skb->nh.iph; |
| } |
| #endif |
| |
| #if !defined(T3_TCP_HDR) |
| static inline struct tcphdr *tcp_hdr(const struct sk_buff *skb) |
| { |
| return skb->h.th; |
| } |
| #endif |
| |
| #if !defined(T3_RESET_MAC_HEADER) |
| static inline void skb_reset_mac_header(struct sk_buff *skb) |
| { |
| skb->mac.raw = skb->data; |
| } |
| #endif |
| |
| #if !defined(T3_MAC_HEADER) |
| static inline unsigned char *skb_mac_header(struct sk_buff *skb) |
| { |
| return skb->mac.raw; |
| } |
| #endif |
| |
| static inline void skb_reset_network_header(struct sk_buff *skb) |
| { |
| skb->nh.raw = skb->data; |
| } |
| |
| static inline void skb_reset_transport_header(struct sk_buff *skb) |
| { |
| skb->h.raw = skb->data; |
| } |
| |
| static inline void cxgb3_set_skb_header(struct sk_buff *skb, |
| struct iphdr *ip_hdr, |
| int offset) |
| { |
| skb->nh.iph = ip_hdr; |
| } |
| |
| #endif /* NEW_SKB_OFFSET */ |
| |
| #if !defined(ARP_HDR) |
| static inline struct arphdr *arp_hdr(const struct sk_buff *skb) |
| { |
| return (struct arphdr *)skb->nh.arph; |
| } |
| #endif /* !ARP_HDR */ |
| |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) |
| #if defined(ETHTOOL_GPERMADDR) |
| #define CXGB3_ETHTOOL_GPERMADDR ETHTOOL_GPERMADDR |
| #endif |
| #endif |
| |
| #if !defined(TRANSPORT_HEADER) |
| #define transport_header h.raw |
| #endif |
| |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) |
| #define SET_MODULE_OWNER(module) |
| #define INET_PROC_DIR init_net.proc_net |
| #else |
| #define INET_PROC_DIR proc_net |
| #endif |
| |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30) |
| #define SET_PROC_NODE_OWNER(_p, _owner) \ |
| do { (_p)->owner = (_owner); } while (0) |
| #else |
| #define SET_PROC_NODE_OWNER(_p, _owner) \ |
| do { } while (0) |
| #endif |
| |
| #if defined(NAPI_UPDATE) |
| #define SGE_GET_OFLD_QS(napi, dev) \ |
| container_of(napi, struct sge_qset, napi) |
| |
| #define DECLARE_OFLD_POLL(napi, dev, budget) \ |
| static int ofld_poll(struct napi_struct *napi, int budget) |
| |
| #define DECLARE_NAPI_RX_HANDLER(napi, dev, budget) \ |
| static int napi_rx_handler(struct napi_struct *napi, int budget) |
| |
| #else |
| #define SGE_GET_OFLD_QS(napi, dev) \ |
| ((struct port_info *)netdev_priv(dev))->qs |
| |
| #define DECLARE_OFLD_POLL(napi, dev, budget) \ |
| static int ofld_poll(struct net_device *dev, int *budget) |
| |
| #define DECLARE_NAPI_RX_HANDLER(napi, dev, budget) \ |
| static int napi_rx_handler(struct net_device *dev, int *budget) |
| |
| #endif /* NAPI_UPDATE */ |
| |
| |
| #if !defined(VLAN_DEV_API) |
| #include <linux/if_vlan.h> |
| #if defined(VLAN_DEV_INFO) |
| static inline struct vlan_dev_info *vlan_dev_info(const struct net_device *dev) |
| { |
| return VLAN_DEV_INFO(dev); |
| } |
| #endif |
| |
| static inline u16 vlan_dev_vlan_id(const struct net_device *dev) |
| { |
| return vlan_dev_info(dev)->vlan_id; |
| } |
| |
| static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev) |
| { |
| return vlan_dev_info(dev)->real_dev; |
| } |
| #else /* VLAN_DEV_API */ |
| #if defined(RHEL_RELEASE_CODE) |
| #if RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,7) && \ |
| RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6,0) |
| #include <linux/if_vlan.h> |
| static inline u16 vlan_dev_vlan_id(const struct net_device *dev) |
| { |
| return VLAN_DEV_INFO(dev)->vlan_id; |
| } |
| #endif |
| #endif /* RHEL_RELEASE_CODE */ |
| #endif /* VLAN_DEV_API */ |
| |
| #if defined(PDEV_MAPPING) |
| static inline int t3_pci_dma_mapping_error(struct pci_dev *pdev, |
| dma_addr_t dma_addr) |
| { |
| return pci_dma_mapping_error(pdev, dma_addr); |
| } |
| #else |
| static inline int t3_pci_dma_mapping_error(struct pci_dev *pdev, |
| dma_addr_t dma_addr) |
| { |
| return pci_dma_mapping_error(dma_addr); |
| } |
| #endif |
| |
| #ifndef DMA_BIT_MASK |
| #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) |
| #endif |
| |
| #if !defined(MQ_TX) |
| struct netdev_queue {}; |
| |
| static inline void t3_compat_set_num_tx_queues(struct net_device *dev, |
| int n) |
| {} |
| |
| static inline struct netdev_queue * netdev_get_tx_queue(struct net_device *dev, |
| int qidx) |
| { |
| return NULL; |
| } |
| |
| #define netif_tx_start_all_queues netif_start_queue |
| #define netif_tx_stop_all_queues netif_stop_queue |
| |
| static inline void t3_netif_tx_stop_queue(struct net_device *dev, |
| struct netdev_queue *txq) |
| { |
| netif_stop_queue(dev); |
| } |
| |
| static inline void t3_netif_tx_wake_queue(struct net_device *dev, |
| struct netdev_queue *txq) |
| { |
| netif_wake_queue(dev); |
| } |
| |
| static inline int t3_netif_tx_queue_stopped(struct net_device *dev, |
| struct netdev_queue *txq) |
| { |
| return netif_queue_stopped(dev); |
| } |
| |
| #ifndef ALLOC_ETHERDEV_MQ_DEF |
| #include <linux/etherdevice.h> |
| static inline struct net_device * alloc_etherdev_mq(int sizeof_priv, |
| int n_txq) |
| { |
| return alloc_etherdev(sizeof_priv); |
| } |
| #else |
| #if defined(RHEL_RELEASE_CODE) |
| /* RHEL 5.6 (and above) expects number of queues to be 1 (hardcoded) */ |
| #if RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5, 6) |
| #define alloc_etherdev_mq(sizeof_priv, n_txq) alloc_etherdev(sizeof_priv) |
| #endif /* RHEL_RELEASE_VERSION(5, 6) */ |
| #endif /* RHEL_RELEASE_CODE */ |
| #endif /* ALLOC_ETHERDEV_MQ_DEF */ |
| |
| #else /* The stack supports TX multiqueues */ |
| static inline void t3_compat_set_num_tx_queues(struct net_device *dev, |
| int n) |
| { |
| dev->real_num_tx_queues = n; |
| } |
| |
| static inline void t3_netif_tx_stop_queue(struct net_device *dev, |
| struct netdev_queue *txq) |
| { |
| netif_tx_stop_queue(txq); |
| } |
| |
| static inline void t3_netif_tx_wake_queue(struct net_device *dev, |
| struct netdev_queue *txq) |
| { |
| netif_tx_wake_queue(txq); |
| } |
| |
| static inline int t3_netif_tx_queue_stopped(struct net_device *dev, |
| struct netdev_queue *txq) |
| { |
| return netif_tx_queue_stopped(txq); |
| } |
| |
| #endif |
| |
| #if !defined(SKB_RECORD_RX_QUEUE) |
| static inline void skb_record_rx_queue(struct sk_buff *skb, u16 rx_queue) |
| {} |
| #endif |
| |
| #if !defined(CXGB3_NIPQUAD) |
| #define NIPQUAD(addr) \ |
| ((unsigned char *)&addr)[0], \ |
| ((unsigned char *)&addr)[1], \ |
| ((unsigned char *)&addr)[2], \ |
| ((unsigned char *)&addr)[3] |
| #define NIPQUAD_FMT "%u.%u.%u.%u" |
| #endif |
| |
| #if !defined(USECS_TO_JIFFIES) |
| static inline unsigned long usecs_to_jiffies(const unsigned int u) |
| { |
| if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET)) |
| return MAX_JIFFY_OFFSET; |
| #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ) |
| return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ); |
| #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC) |
| return u * (HZ / USEC_PER_SEC); |
| #else |
| return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32) |
| >> USEC_TO_HZ_SHR32; |
| #endif |
| } |
| #endif |
| |
| #endif |