/******************************************************************************* Intel(R) Gigabit Ethernet Linux driver Copyright(c) 2007-2009 Intel Corporation. This program is free software; you can redistribute it and/or modify it under the terms and conditions of the GNU General Public License, version 2, as published by the Free Software Foundation. This program is distributed in the hope it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. The full GNU General Public License is included in this distribution in the file called "COPYING". Contact Information: e1000-devel Mailing List Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 *******************************************************************************/ #include "igb.h" #include "kcompat.h" /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,21) ) struct sk_buff * _kc_skb_pad(struct sk_buff *skb, int pad) { struct sk_buff *nskb; /* If the skbuff is non linear tailroom is always zero.. */ if(skb_tailroom(skb) >= pad) { memset(skb->data+skb->len, 0, pad); return skb; } nskb = skb_copy_expand(skb, skb_headroom(skb), skb_tailroom(skb) + pad, GFP_ATOMIC); kfree_skb(skb); if(nskb) memset(nskb->data+nskb->len, 0, pad); return nskb; } #endif /* < 2.4.21 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,13) ) /**************************************/ /* PCI DMA MAPPING */ #if defined(CONFIG_HIGHMEM) #ifndef PCI_DRAM_OFFSET #define PCI_DRAM_OFFSET 0 #endif u64 _kc_pci_map_page(struct pci_dev *dev, struct page *page, unsigned long offset, size_t size, int direction) { return (((u64) (page - mem_map) << PAGE_SHIFT) + offset + PCI_DRAM_OFFSET); } #else /* CONFIG_HIGHMEM */ u64 _kc_pci_map_page(struct pci_dev *dev, struct page *page, unsigned long offset, size_t size, int direction) { return pci_map_single(dev, (void *)page_address(page) + offset, size, direction); } #endif /* CONFIG_HIGHMEM */ void _kc_pci_unmap_page(struct pci_dev *dev, u64 dma_addr, size_t size, int direction) { return pci_unmap_single(dev, dma_addr, size, direction); } #endif /* 2.4.13 => 2.4.3 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,3) ) /**************************************/ /* PCI DRIVER API */ int _kc_pci_set_dma_mask(struct pci_dev *dev, dma_addr_t mask) { if (!pci_dma_supported(dev, mask)) return -EIO; dev->dma_mask = mask; return 0; } int _kc_pci_request_regions(struct pci_dev *dev, char *res_name) { int i; for (i = 0; i < 6; i++) { if (pci_resource_len(dev, i) == 0) continue; if (pci_resource_flags(dev, i) & IORESOURCE_IO) { if (!request_region(pci_resource_start(dev, i), pci_resource_len(dev, i), res_name)) { pci_release_regions(dev); return -EBUSY; } } else if (pci_resource_flags(dev, i) & IORESOURCE_MEM) { if (!request_mem_region(pci_resource_start(dev, i), pci_resource_len(dev, i), res_name)) { pci_release_regions(dev); return -EBUSY; } } } return 0; } void _kc_pci_release_regions(struct pci_dev *dev) { int i; for (i = 0; i < 6; i++) { if (pci_resource_len(dev, i) == 0) continue; if (pci_resource_flags(dev, i) & IORESOURCE_IO) release_region(pci_resource_start(dev, i), pci_resource_len(dev, i)); else if (pci_resource_flags(dev, i) & IORESOURCE_MEM) release_mem_region(pci_resource_start(dev, i), pci_resource_len(dev, i)); } } /**************************************/ /* NETWORK DRIVER API */ struct net_device * _kc_alloc_etherdev(int sizeof_priv) { struct net_device *dev; int alloc_size; alloc_size = sizeof(*dev) + sizeof_priv + IFNAMSIZ + 31; dev = kmalloc(alloc_size, GFP_KERNEL); if (!dev) return NULL; memset(dev, 0, alloc_size); if (sizeof_priv) dev->priv = (void *) (((unsigned long)(dev + 1) + 31) & ~31); dev->name[0] = '\0'; ether_setup(dev); return dev; } int _kc_is_valid_ether_addr(u8 *addr) { const char zaddr[6] = { 0, }; return !(addr[0] & 1) && memcmp(addr, zaddr, 6); } #endif /* 2.4.3 => 2.4.0 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,6) ) int _kc_pci_set_power_state(struct pci_dev *dev, int state) { return 0; } int _kc_pci_enable_wake(struct pci_dev *pdev, u32 state, int enable) { return 0; } #endif /* 2.4.6 => 2.4.3 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) ) void _kc_skb_fill_page_desc(struct sk_buff *skb, int i, struct page *page, int off, int size) { skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; frag->page = page; frag->page_offset = off; frag->size = size; skb_shinfo(skb)->nr_frags = i + 1; } /* * Original Copyright: * find_next_bit.c: fallback find next bit implementation * * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) */ /** * find_next_bit - find the next set bit in a memory region * @addr: The address to base the search on * @offset: The bitnumber to start searching at * @size: The maximum size to search */ unsigned long find_next_bit(const unsigned long *addr, unsigned long size, unsigned long offset) { const unsigned long *p = addr + BITOP_WORD(offset); unsigned long result = offset & ~(BITS_PER_LONG-1); unsigned long tmp; if (offset >= size) return size; size -= result; offset %= BITS_PER_LONG; if (offset) { tmp = *(p++); tmp &= (~0UL << offset); if (size < BITS_PER_LONG) goto found_first; if (tmp) goto found_middle; size -= BITS_PER_LONG; result += BITS_PER_LONG; } while (size & ~(BITS_PER_LONG-1)) { if ((tmp = *(p++))) goto found_middle; result += BITS_PER_LONG; size -= BITS_PER_LONG; } if (!size) return result; tmp = *p; found_first: tmp &= (~0UL >> (BITS_PER_LONG - size)); if (tmp == 0UL) /* Are any bits set? */ return result + size; /* Nope. */ found_middle: return result + ffs(tmp); } #endif /* 2.6.0 => 2.4.6 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) ) void *_kc_kzalloc(size_t size, int flags) { void *ret = kmalloc(size, flags); if (ret) memset(ret, 0, size); return ret; } #endif /* <= 2.6.13 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18) ) struct sk_buff *_kc_netdev_alloc_skb(struct net_device *dev, unsigned int length) { /* 16 == NET_PAD_SKB */ struct sk_buff *skb; skb = alloc_skb(length + 16, GFP_ATOMIC); if (likely(skb != NULL)) { skb_reserve(skb, 16); skb->dev = dev; } return skb; } #endif /* <= 2.6.17 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) ) int _kc_pci_save_state(struct pci_dev *pdev) { struct net_device *netdev = pci_get_drvdata(pdev); struct adapter_struct *adapter = netdev_priv(netdev); int size = PCI_CONFIG_SPACE_LEN, i; u16 pcie_cap_offset = pci_find_capability(pdev, PCI_CAP_ID_EXP); u16 pcie_link_status; if (pcie_cap_offset) { if (!pci_read_config_word(pdev, pcie_cap_offset + PCIE_LINK_STATUS, &pcie_link_status)) size = PCIE_CONFIG_SPACE_LEN; } pci_config_space_ich8lan(); #ifdef HAVE_PCI_ERS if (adapter->config_space == NULL) #else WARN_ON(adapter->config_space != NULL); #endif adapter->config_space = kmalloc(size, GFP_KERNEL); if (!adapter->config_space) { printk(KERN_ERR "Out of memory in pci_save_state\n"); return -ENOMEM; } for (i = 0; i < (size / 4); i++) pci_read_config_dword(pdev, i * 4, &adapter->config_space[i]); return 0; } void _kc_pci_restore_state(struct pci_dev * pdev) { struct net_device *netdev = pci_get_drvdata(pdev); struct adapter_struct *adapter = netdev_priv(netdev); int size = PCI_CONFIG_SPACE_LEN, i; u16 pcie_cap_offset; u16 pcie_link_status; if (adapter->config_space != NULL) { pcie_cap_offset = pci_find_capability(pdev, PCI_CAP_ID_EXP); if (pcie_cap_offset && !pci_read_config_word(pdev, pcie_cap_offset + PCIE_LINK_STATUS, &pcie_link_status)) size = PCIE_CONFIG_SPACE_LEN; pci_config_space_ich8lan(); for (i = 0; i < (size / 4); i++) pci_write_config_dword(pdev, i * 4, adapter->config_space[i]); #ifndef HAVE_PCI_ERS kfree(adapter->config_space); adapter->config_space = NULL; #endif } } #ifdef HAVE_PCI_ERS void _kc_free_netdev(struct net_device *netdev) { struct adapter_struct *adapter = netdev_priv(netdev); if (adapter->config_space != NULL) kfree(adapter->config_space); #ifdef CONFIG_SYSFS if (netdev->reg_state == NETREG_UNINITIALIZED) { kfree((char *)netdev - netdev->padded); } else { BUG_ON(netdev->reg_state != NETREG_UNREGISTERED); netdev->reg_state = NETREG_RELEASED; class_device_put(&netdev->class_dev); } #else kfree((char *)netdev - netdev->padded); #endif } #endif #endif /* <= 2.6.18 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) ) #ifdef NAPI struct net_device *napi_to_poll_dev(struct napi_struct *napi) { struct adapter_q_vector *q_vector = container_of(napi, struct adapter_q_vector, napi); return &q_vector->poll_dev; } int __kc_adapter_clean(struct net_device *netdev, int *budget) { int work_done; int work_to_do = min(*budget, netdev->quota); /* kcompat.h netif_napi_add puts napi struct in "fake netdev->priv" */ struct napi_struct *napi = netdev->priv; work_done = napi->poll(napi, work_to_do); *budget -= work_done; netdev->quota -= work_done; return (work_done >= work_to_do) ? 1 : 0; } #endif /* NAPI */ #endif /* <= 2.6.24 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27) ) #ifdef HAVE_TX_MQ void _kc_netif_tx_stop_all_queues(struct net_device *netdev) { struct adapter_struct *adapter = netdev_priv(netdev); int i; netif_stop_queue(netdev); if (netif_is_multiqueue(netdev)) for (i = 0; i < adapter->num_tx_queues; i++) netif_stop_subqueue(netdev, i); } void _kc_netif_tx_wake_all_queues(struct net_device *netdev) { struct adapter_struct *adapter = netdev_priv(netdev); int i; netif_wake_queue(netdev); if (netif_is_multiqueue(netdev)) for (i = 0; i < adapter->num_tx_queues; i++) netif_wake_subqueue(netdev, i); } void _kc_netif_tx_start_all_queues(struct net_device *netdev) { struct adapter_struct *adapter = netdev_priv(netdev); int i; netif_start_queue(netdev); if (netif_is_multiqueue(netdev)) for (i = 0; i < adapter->num_tx_queues; i++) netif_start_subqueue(netdev, i); } #endif /* HAVE_TX_MQ */ #endif /* < 2.6.27 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28) ) int _kc_pci_prepare_to_sleep(struct pci_dev *dev) { pci_power_t target_state; int error; target_state = pci_choose_state(dev, PMSG_SUSPEND); pci_enable_wake(dev, target_state, true); error = pci_set_power_state(dev, target_state); if (error) pci_enable_wake(dev, target_state, false); return error; } int _kc_pci_wake_from_d3(struct pci_dev *dev, bool enable) { int err; err = pci_enable_wake(dev, PCI_D3cold, enable); if (err) goto out; err = pci_enable_wake(dev, PCI_D3hot, enable); out: return err; } #endif /* < 2.6.28 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) ) void _kc_pci_disable_link_state(struct pci_dev *pdev, int state) { struct pci_dev *parent = pdev->bus->self; u16 link_state; int pos; if (!parent) return; pos = pci_find_capability(parent, PCI_CAP_ID_EXP); if (pos) { pci_read_config_word(parent, pos + PCI_EXP_LNKCTL, &link_state); link_state &= ~state; pci_write_config_word(parent, pos + PCI_EXP_LNKCTL, link_state); } } #endif /* < 2.6.29 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30) ) #ifdef HAVE_NETDEV_SELECT_QUEUE #include static u32 _kc_simple_tx_hashrnd; static u32 _kc_simple_tx_hashrnd_initialized; u16 _kc_skb_tx_hash(struct net_device *dev, struct sk_buff *skb) { u32 addr1, addr2, ports; u32 hash, ihl; u8 ip_proto = 0; if (unlikely(!_kc_simple_tx_hashrnd_initialized)) { get_random_bytes(&_kc_simple_tx_hashrnd, 4); _kc_simple_tx_hashrnd_initialized = 1; } switch (skb->protocol) { case htons(ETH_P_IP): if (!(ip_hdr(skb)->frag_off & htons(IP_MF | IP_OFFSET))) ip_proto = ip_hdr(skb)->protocol; addr1 = ip_hdr(skb)->saddr; addr2 = ip_hdr(skb)->daddr; ihl = ip_hdr(skb)->ihl; break; #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) case htons(ETH_P_IPV6): ip_proto = ipv6_hdr(skb)->nexthdr; addr1 = ipv6_hdr(skb)->saddr.s6_addr32[3]; addr2 = ipv6_hdr(skb)->daddr.s6_addr32[3]; ihl = (40 >> 2); break; #endif default: return 0; } switch (ip_proto) { case IPPROTO_TCP: case IPPROTO_UDP: case IPPROTO_DCCP: case IPPROTO_ESP: case IPPROTO_AH: case IPPROTO_SCTP: case IPPROTO_UDPLITE: ports = *((u32 *) (skb_network_header(skb) + (ihl * 4))); break; default: ports = 0; break; } hash = jhash_3words(addr1, addr2, ports, _kc_simple_tx_hashrnd); return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32); } #endif /* HAVE_NETDEV_SELECT_QUEUE */ #endif /* < 2.6.30 */ /*****************************************************************************/ #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33) ) struct sk_buff *_kc_netdev_alloc_skb_ip_align(struct net_device *dev, unsigned int length) { struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN); if (NET_IP_ALIGN && skb) skb_reserve(skb, NET_IP_ALIGN); return skb; } #endif /* < 2.6.33 */