/* * Linux-specific abstractions to gain some independence from linux kernel versions. * Pave over some 2.2 versus 2.4 versus 2.6 kernel differences. * * Copyright (C) 1999-2010, Broadcom Corporation * * Unless you and Broadcom execute a separate written software license * agreement governing use of this software, this software is licensed to you * under the terms of the GNU General Public License version 2 (the "GPL"), * available at http://www.broadcom.com/licenses/GPLv2.php, with the * following added to such license: * * As a special exception, the copyright holders of this software give you * permission to link this software with independent modules, and to copy and * distribute the resulting executable under terms of your choice, provided that * you also meet, for each linked independent module, the terms and conditions of * the license of that module. An independent module is a module which is not * derived from this software. The special exception does not apply to any * modifications of the software. * * Notwithstanding the above, under no circumstances may you combine this * software in any way with any other Broadcom software provided under a license * other than the GPL, without Broadcom's express prior written consent. * * $Id: linuxver.h,v 13.38.8.1.8.6 2010/04/29 05:00:46 Exp $ */ #ifndef _linuxver_h_ #define _linuxver_h_ #include #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)) #include #elif (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)) #include #endif #include #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 0)) #ifdef __UNDEF_NO_VERSION__ #undef __NO_VERSION__ #else #define __NO_VERSION__ #endif #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0) #define module_param(_name_, _type_, _perm_) MODULE_PARM(_name_, "i") #define module_param_string(_name_, _string_, _size_, _perm_) \ MODULE_PARM(_string_, "c" __MODULE_STRING(_size_)) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 9)) #include #else #include #endif #include #include #include #include #include #include #include #include #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)) #undef IP_TOS #endif #include #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 41)) #include #else #include #ifndef work_struct #define work_struct tq_struct #endif #ifndef INIT_WORK #define INIT_WORK(_work, _func, _data) INIT_TQUEUE((_work), (_func), (_data)) #endif #ifndef schedule_work #define schedule_work(_work) schedule_task((_work)) #endif #ifndef flush_scheduled_work #define flush_scheduled_work() flush_scheduled_tasks() #endif #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) #define MY_INIT_WORK(_work, _func, _data) INIT_WORK(_work, _func) #else #define MY_INIT_WORK(_work, _func, _data) INIT_WORK(_work, _func, _data) typedef void (*work_func_t)(void *work); #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)) #ifndef IRQ_NONE typedef void irqreturn_t; #define IRQ_NONE #define IRQ_HANDLED #define IRQ_RETVAL(x) #endif #else typedef irqreturn_t(*FN_ISR) (int irq, void *dev_id, struct pt_regs *ptregs); #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18) #define IRQF_SHARED SA_SHIRQ #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 17) #ifdef CONFIG_NET_RADIO #define CONFIG_WIRELESS_EXT #endif #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 67) #ifndef SANDGATE2G #define MOD_INC_USE_COUNT #endif #endif #ifndef __exit #define __exit #endif #ifndef __devexit #define __devexit #endif #ifndef __devinit #define __devinit __init #endif #ifndef __devinitdata #define __devinitdata #endif #ifndef __devexit_p #define __devexit_p(x) x #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)) #define pci_get_drvdata(dev) (dev)->sysdata #define pci_set_drvdata(dev, value) (dev)->sysdata = (value) struct pci_device_id { unsigned int vendor, device; unsigned int subvendor, subdevice; unsigned int class, class_mask; unsigned long driver_data; }; struct pci_driver { struct list_head node; char *name; const struct pci_device_id *id_table; int (*probe)(struct pci_dev *dev, const struct pci_device_id *id); void (*remove)(struct pci_dev *dev); void (*suspend)(struct pci_dev *dev); void (*resume)(struct pci_dev *dev); }; #define MODULE_DEVICE_TABLE(type, name) #define PCI_ANY_ID (~0) #define pci_module_init pci_register_driver extern int pci_register_driver(struct pci_driver *drv); extern void pci_unregister_driver(struct pci_driver *drv); #endif #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)) #define pci_module_init pci_register_driver #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 2, 18)) #ifdef MODULE #define module_init(x) int init_module(void) { return x(); } #define module_exit(x) void cleanup_module(void) { x(); } #else #define module_init(x) __initcall(x); #define module_exit(x) __exitcall(x); #endif #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 48)) #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); pos = pos->next) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 13)) #define pci_resource_start(dev, bar) ((dev)->base_address[(bar)]) #elif (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 44)) #define pci_resource_start(dev, bar) ((dev)->resource[(bar)].start) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 23)) #define pci_enable_device(dev) do { } while (0) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 14)) #define net_device device #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 42)) #ifndef PCI_DMA_TODEVICE #define PCI_DMA_TODEVICE 1 #define PCI_DMA_FROMDEVICE 2 #endif typedef u32 dma_addr_t; static inline int get_order(unsigned long size) { int order; size = (size-1) >> (PAGE_SHIFT-1); order = -1; do { size >>= 1; order++; } while (size); return order; } static inline void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size, dma_addr_t *dma_handle) { void *ret; int gfp = GFP_ATOMIC | GFP_DMA; ret = (void *)__get_free_pages(gfp, get_order(size)); if (ret != NULL) { memset(ret, 0, size); *dma_handle = virt_to_bus(ret); } return ret; } static inline void pci_free_consistent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle) { free_pages((unsigned long)vaddr, get_order(size)); } #define pci_map_single(cookie, address, size, dir) virt_to_bus(address) #define pci_unmap_single(cookie, address, size, dir) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 43)) #define dev_kfree_skb_any(a) dev_kfree_skb(a) #define netif_down(dev) do { (dev)->start = 0; } while (0) #ifndef _COMPAT_NETDEVICE_H #define dev_kfree_skb_irq(a) dev_kfree_skb(a) #define netif_wake_queue(dev) \ do { clear_bit(0, &(dev)->tbusy); mark_bh(NET_BH); } while (0) #define netif_stop_queue(dev) set_bit(0, &(dev)->tbusy) static inline void netif_start_queue(struct net_device *dev) { dev->tbusy = 0; dev->interrupt = 0; dev->start = 1; } #define netif_queue_stopped(dev) (dev)->tbusy #define netif_running(dev) (dev)->start #endif #define netif_device_attach(dev) netif_start_queue(dev) #define netif_device_detach(dev) netif_stop_queue(dev) #define tasklet_struct tq_struct static inline void tasklet_schedule(struct tasklet_struct *tasklet) { queue_task(tasklet, &tq_immediate); mark_bh(IMMEDIATE_BH); } static inline void tasklet_init(struct tasklet_struct *tasklet, void (*func)(unsigned long), unsigned long data) { tasklet->next = NULL; tasklet->sync = 0; tasklet->routine = (void (*)(void *))func; tasklet->data = (void *)data; } #define tasklet_kill(tasklet) { do {} while (0); } #define del_timer_sync(timer) del_timer(timer) #else #define netif_down(dev) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 3)) #define PREPARE_TQUEUE(_tq, _routine, _data) \ do { \ (_tq)->routine = _routine; \ (_tq)->data = _data; \ } while (0) #define INIT_TQUEUE(_tq, _routine, _data) \ do { \ INIT_LIST_HEAD(&(_tq)->list); \ (_tq)->sync = 0; \ PREPARE_TQUEUE((_tq), (_routine), (_data)); \ } while (0) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 6)) static inline int pci_save_state(struct pci_dev *dev, u32 *buffer) { int i; if (buffer) { for (i = 0; i < 16; i++) pci_read_config_dword(dev, i * 4, &buffer[i]); } return 0; } static inline int pci_restore_state(struct pci_dev *dev, u32 *buffer) { int i; if (buffer) { for (i = 0; i < 16; i++) pci_write_config_dword(dev, i * 4, buffer[i]); } else { for (i = 0; i < 6; i ++) pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + (i * 4), pci_resource_start(dev, i)); pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq); } return 0; } #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 19)) #define read_c0_count() read_32bit_cp0_register(CP0_COUNT) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)) #ifndef SET_MODULE_OWNER #define SET_MODULE_OWNER(dev) do {} while (0) #define OLD_MOD_INC_USE_COUNT MOD_INC_USE_COUNT #define OLD_MOD_DEC_USE_COUNT MOD_DEC_USE_COUNT #else #define OLD_MOD_INC_USE_COUNT do {} while (0) #define OLD_MOD_DEC_USE_COUNT do {} while (0) #endif #else #ifndef SET_MODULE_OWNER #define SET_MODULE_OWNER(dev) do {} while (0) #endif #ifndef MOD_INC_USE_COUNT #define MOD_INC_USE_COUNT do {} while (0) #endif #ifndef MOD_DEC_USE_COUNT #define MOD_DEC_USE_COUNT do {} while (0) #endif #define OLD_MOD_INC_USE_COUNT MOD_INC_USE_COUNT #define OLD_MOD_DEC_USE_COUNT MOD_DEC_USE_COUNT #endif #ifndef SET_NETDEV_DEV #define SET_NETDEV_DEV(net, pdev) do {} while (0) #endif #ifndef HAVE_FREE_NETDEV #define free_netdev(dev) kfree(dev) #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)) #define af_packet_priv data #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 11) #define DRV_SUSPEND_STATE_TYPE pm_message_t #else #define DRV_SUSPEND_STATE_TYPE uint32 #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) #define CHECKSUM_HW CHECKSUM_PARTIAL #endif #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)) #define KILL_PROC(pid, sig) \ { \ struct task_struct *tsk; \ tsk = pid_task(find_vpid(pid), PIDTYPE_PID); \ if (tsk) send_sig(sig, tsk, 1); \ } #else #define KILL_PROC(pid, sig) \ { \ kill_proc(pid, sig, 1); \ } #endif #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)) #define netdev_priv(dev) dev->priv #endif #endif