1 /* 2 * Linux-specific abstractions to gain some independence from linux kernel versions. 3 * Pave over some 2.2 versus 2.4 versus 2.6 kernel differences. 4 * 5 * Copyright (C) 1999-2010, Broadcom Corporation 6 * 7 * Unless you and Broadcom execute a separate written software license 8 * agreement governing use of this software, this software is licensed to you 9 * under the terms of the GNU General Public License version 2 (the "GPL"), 10 * available at http://www.broadcom.com/licenses/GPLv2.php, with the 11 * following added to such license: 12 * 13 * As a special exception, the copyright holders of this software give you 14 * permission to link this software with independent modules, and to copy and 15 * distribute the resulting executable under terms of your choice, provided that 16 * you also meet, for each linked independent module, the terms and conditions of 17 * the license of that module. An independent module is a module which is not 18 * derived from this software. The special exception does not apply to any 19 * modifications of the software. 20 * 21 * Notwithstanding the above, under no circumstances may you combine this 22 * software in any way with any other Broadcom software provided under a license 23 * other than the GPL, without Broadcom's express prior written consent. 24 * 25 * $Id: linuxver.h,v 13.38.8.1.8.6 2010/04/29 05:00:46 Exp $ 26 */ 27 28 29 #ifndef _linuxver_h_ 30 #define _linuxver_h_ 31 32 #include <linux/version.h> 33 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)) 34 #include <linux/config.h> 35 #elif (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)) 36 #include <linux/autoconf.h> 37 #endif 38 #include <linux/module.h> 39 40 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 0)) 41 42 #ifdef __UNDEF_NO_VERSION__ 43 #undef __NO_VERSION__ 44 #else 45 #define __NO_VERSION__ 46 #endif 47 #endif 48 49 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0) 50 #define module_param(_name_, _type_, _perm_) MODULE_PARM(_name_, "i") 51 #define module_param_string(_name_, _string_, _size_, _perm_) \ 52 MODULE_PARM(_string_, "c" __MODULE_STRING(_size_)) 53 #endif 54 55 56 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 9)) 57 #include <linux/malloc.h> 58 #else 59 #include <linux/slab.h> 60 #endif 61 62 #include <linux/types.h> 63 #include <linux/init.h> 64 #include <linux/mm.h> 65 #include <linux/string.h> 66 #include <linux/pci.h> 67 #include <linux/interrupt.h> 68 #include <linux/netdevice.h> 69 #include <linux/semaphore.h> 70 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)) 71 #undef IP_TOS 72 #endif 73 #include <asm/io.h> 74 75 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 41)) 76 #include <linux/workqueue.h> 77 #else 78 #include <linux/tqueue.h> 79 #ifndef work_struct 80 #define work_struct tq_struct 81 #endif 82 #ifndef INIT_WORK 83 #define INIT_WORK(_work, _func, _data) INIT_TQUEUE((_work), (_func), (_data)) 84 #endif 85 #ifndef schedule_work 86 #define schedule_work(_work) schedule_task((_work)) 87 #endif 88 #ifndef flush_scheduled_work 89 #define flush_scheduled_work() flush_scheduled_tasks() 90 #endif 91 #endif 92 93 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) 94 #define MY_INIT_WORK(_work, _func, _data) INIT_WORK(_work, _func) 95 #else 96 #define MY_INIT_WORK(_work, _func, _data) INIT_WORK(_work, _func, _data) 97 typedef void (*work_func_t)(void *work); 98 #endif 99 100 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)) 101 102 #ifndef IRQ_NONE 103 typedef void irqreturn_t; 104 #define IRQ_NONE 105 #define IRQ_HANDLED 106 #define IRQ_RETVAL(x) 107 #endif 108 #else 109 typedef irqreturn_t(*FN_ISR) (int irq, void *dev_id, struct pt_regs *ptregs); 110 #endif 111 112 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18) 113 #define IRQF_SHARED SA_SHIRQ 114 #endif 115 116 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 17) 117 #ifdef CONFIG_NET_RADIO 118 #define CONFIG_WIRELESS_EXT 119 #endif 120 #endif 121 122 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 67) 123 #ifndef SANDGATE2G 124 #define MOD_INC_USE_COUNT 125 #endif 126 #endif 127 128 129 #ifndef __exit 130 #define __exit 131 #endif 132 #ifndef __devexit 133 #define __devexit 134 #endif 135 #ifndef __devinit 136 #define __devinit __init 137 #endif 138 #ifndef __devinitdata 139 #define __devinitdata 140 #endif 141 #ifndef __devexit_p 142 #define __devexit_p(x) x 143 #endif 144 145 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)) 146 147 #define pci_get_drvdata(dev) (dev)->sysdata 148 #define pci_set_drvdata(dev, value) (dev)->sysdata = (value) 149 150 151 152 struct pci_device_id { 153 unsigned int vendor, device; 154 unsigned int subvendor, subdevice; 155 unsigned int class, class_mask; 156 unsigned long driver_data; 157 }; 158 159 struct pci_driver { 160 struct list_head node; 161 char *name; 162 const struct pci_device_id *id_table; 163 int (*probe)(struct pci_dev *dev, 164 const struct pci_device_id *id); 165 void (*remove)(struct pci_dev *dev); 166 void (*suspend)(struct pci_dev *dev); 167 void (*resume)(struct pci_dev *dev); 168 }; 169 170 #define MODULE_DEVICE_TABLE(type, name) 171 #define PCI_ANY_ID (~0) 172 173 174 #define pci_module_init pci_register_driver 175 extern int pci_register_driver(struct pci_driver *drv); 176 extern void pci_unregister_driver(struct pci_driver *drv); 177 178 #endif 179 180 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)) 181 #define pci_module_init pci_register_driver 182 #endif 183 184 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 2, 18)) 185 #ifdef MODULE 186 #define module_init(x) int init_module(void) { return x(); } 187 #define module_exit(x) void cleanup_module(void) { x(); } 188 #else 189 #define module_init(x) __initcall(x); 190 #define module_exit(x) __exitcall(x); 191 #endif 192 #endif 193 194 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 48)) 195 #define list_for_each(pos, head) \ 196 for (pos = (head)->next; pos != (head); pos = pos->next) 197 #endif 198 199 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 13)) 200 #define pci_resource_start(dev, bar) ((dev)->base_address[(bar)]) 201 #elif (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 44)) 202 #define pci_resource_start(dev, bar) ((dev)->resource[(bar)].start) 203 #endif 204 205 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 23)) 206 #define pci_enable_device(dev) do { } while (0) 207 #endif 208 209 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 14)) 210 #define net_device device 211 #endif 212 213 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 42)) 214 215 216 217 #ifndef PCI_DMA_TODEVICE 218 #define PCI_DMA_TODEVICE 1 219 #define PCI_DMA_FROMDEVICE 2 220 #endif 221 222 typedef u32 dma_addr_t; 223 224 225 static inline int get_order(unsigned long size) 226 { 227 int order; 228 229 size = (size-1) >> (PAGE_SHIFT-1); 230 order = -1; 231 do { 232 size >>= 1; 233 order++; 234 } while (size); 235 return order; 236 } 237 238 static inline void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size, 239 dma_addr_t *dma_handle) 240 { 241 void *ret; 242 int gfp = GFP_ATOMIC | GFP_DMA; 243 244 ret = (void *)__get_free_pages(gfp, get_order(size)); 245 246 if (ret != NULL) { 247 memset(ret, 0, size); 248 *dma_handle = virt_to_bus(ret); 249 } 250 return ret; 251 } 252 static inline void pci_free_consistent(struct pci_dev *hwdev, size_t size, 253 void *vaddr, dma_addr_t dma_handle) 254 { 255 free_pages((unsigned long)vaddr, get_order(size)); 256 } 257 #define pci_map_single(cookie, address, size, dir) virt_to_bus(address) 258 #define pci_unmap_single(cookie, address, size, dir) 259 260 #endif 261 262 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 43)) 263 264 #define dev_kfree_skb_any(a) dev_kfree_skb(a) 265 #define netif_down(dev) do { (dev)->start = 0; } while (0) 266 267 268 #ifndef _COMPAT_NETDEVICE_H 269 270 271 272 #define dev_kfree_skb_irq(a) dev_kfree_skb(a) 273 #define netif_wake_queue(dev) \ 274 do { clear_bit(0, &(dev)->tbusy); mark_bh(NET_BH); } while (0) 275 #define netif_stop_queue(dev) set_bit(0, &(dev)->tbusy) 276 277 static inline void netif_start_queue(struct net_device *dev) 278 { 279 dev->tbusy = 0; 280 dev->interrupt = 0; 281 dev->start = 1; 282 } 283 284 #define netif_queue_stopped(dev) (dev)->tbusy 285 #define netif_running(dev) (dev)->start 286 287 #endif 288 289 #define netif_device_attach(dev) netif_start_queue(dev) 290 #define netif_device_detach(dev) netif_stop_queue(dev) 291 292 293 #define tasklet_struct tq_struct 294 static inline void tasklet_schedule(struct tasklet_struct *tasklet) 295 { 296 queue_task(tasklet, &tq_immediate); 297 mark_bh(IMMEDIATE_BH); 298 } 299 300 static inline void tasklet_init(struct tasklet_struct *tasklet, 301 void (*func)(unsigned long), 302 unsigned long data) 303 { 304 tasklet->next = NULL; 305 tasklet->sync = 0; 306 tasklet->routine = (void (*)(void *))func; 307 tasklet->data = (void *)data; 308 } 309 #define tasklet_kill(tasklet) { do {} while (0); } 310 311 312 #define del_timer_sync(timer) del_timer(timer) 313 314 #else 315 316 #define netif_down(dev) 317 318 #endif 319 320 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 3)) 321 322 323 #define PREPARE_TQUEUE(_tq, _routine, _data) \ 324 do { \ 325 (_tq)->routine = _routine; \ 326 (_tq)->data = _data; \ 327 } while (0) 328 329 330 #define INIT_TQUEUE(_tq, _routine, _data) \ 331 do { \ 332 INIT_LIST_HEAD(&(_tq)->list); \ 333 (_tq)->sync = 0; \ 334 PREPARE_TQUEUE((_tq), (_routine), (_data)); \ 335 } while (0) 336 337 #endif 338 339 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 6)) 340 341 342 343 static inline int 344 pci_save_state(struct pci_dev *dev, u32 *buffer) 345 { 346 int i; 347 if (buffer) { 348 for (i = 0; i < 16; i++) 349 pci_read_config_dword(dev, i * 4, &buffer[i]); 350 } 351 return 0; 352 } 353 354 static inline int 355 pci_restore_state(struct pci_dev *dev, u32 *buffer) 356 { 357 int i; 358 359 if (buffer) { 360 for (i = 0; i < 16; i++) 361 pci_write_config_dword(dev, i * 4, buffer[i]); 362 } 363 364 else { 365 for (i = 0; i < 6; i ++) 366 pci_write_config_dword(dev, 367 PCI_BASE_ADDRESS_0 + (i * 4), 368 pci_resource_start(dev, i)); 369 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq); 370 } 371 return 0; 372 } 373 374 #endif 375 376 377 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 19)) 378 #define read_c0_count() read_32bit_cp0_register(CP0_COUNT) 379 #endif 380 381 382 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)) 383 #ifndef SET_MODULE_OWNER 384 #define SET_MODULE_OWNER(dev) do {} while (0) 385 #define OLD_MOD_INC_USE_COUNT MOD_INC_USE_COUNT 386 #define OLD_MOD_DEC_USE_COUNT MOD_DEC_USE_COUNT 387 #else 388 #define OLD_MOD_INC_USE_COUNT do {} while (0) 389 #define OLD_MOD_DEC_USE_COUNT do {} while (0) 390 #endif 391 #else 392 #ifndef SET_MODULE_OWNER 393 #define SET_MODULE_OWNER(dev) do {} while (0) 394 #endif 395 #ifndef MOD_INC_USE_COUNT 396 #define MOD_INC_USE_COUNT do {} while (0) 397 #endif 398 #ifndef MOD_DEC_USE_COUNT 399 #define MOD_DEC_USE_COUNT do {} while (0) 400 #endif 401 #define OLD_MOD_INC_USE_COUNT MOD_INC_USE_COUNT 402 #define OLD_MOD_DEC_USE_COUNT MOD_DEC_USE_COUNT 403 #endif 404 405 #ifndef SET_NETDEV_DEV 406 #define SET_NETDEV_DEV(net, pdev) do {} while (0) 407 #endif 408 409 #ifndef HAVE_FREE_NETDEV 410 #define free_netdev(dev) kfree(dev) 411 #endif 412 413 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)) 414 415 #define af_packet_priv data 416 #endif 417 418 419 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 11) 420 #define DRV_SUSPEND_STATE_TYPE pm_message_t 421 #else 422 #define DRV_SUSPEND_STATE_TYPE uint32 423 #endif 424 425 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) 426 #define CHECKSUM_HW CHECKSUM_PARTIAL 427 #endif 428 429 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)) 430 #define KILL_PROC(pid, sig) \ 431 { \ 432 struct task_struct *tsk; \ 433 tsk = pid_task(find_vpid(pid), PIDTYPE_PID); \ 434 if (tsk) send_sig(sig, tsk, 1); \ 435 } 436 #else 437 #define KILL_PROC(pid, sig) \ 438 { \ 439 kill_proc(pid, sig, 1); \ 440 } 441 #endif 442 443 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)) 444 #define netdev_priv(dev) dev->priv 445 #endif 446 447 #endif 448
