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
get_order(unsigned long size)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
pci_alloc_consistent(struct pci_dev * hwdev,size_t size,dma_addr_t * dma_handle)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 }
pci_free_consistent(struct pci_dev * hwdev,size_t size,void * vaddr,dma_addr_t dma_handle)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
netif_start_queue(struct net_device * dev)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
tasklet_schedule(struct tasklet_struct * tasklet)294 static inline void tasklet_schedule(struct tasklet_struct *tasklet)
295 {
296 queue_task(tasklet, &tq_immediate);
297 mark_bh(IMMEDIATE_BH);
298 }
299
tasklet_init(struct tasklet_struct * tasklet,void (* func)(unsigned long),unsigned long data)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
pci_save_state(struct pci_dev * dev,u32 * buffer)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
pci_restore_state(struct pci_dev * dev,u32 * buffer)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