Commit | Line | Data |
---|---|---|
f9f08d70 LF |
1 | /****************************************************************************** |
2 | * | |
3 | * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify it | |
6 | * under the terms of version 2 of the GNU General Public License as | |
7 | * published by the Free Software Foundation. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
12 | * more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License along with | |
15 | * this program; if not, write to the Free Software Foundation, Inc., | |
16 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA | |
17 | * | |
18 | * | |
19 | ******************************************************************************/ | |
20 | #ifndef __OSDEP_SERVICE_H_ | |
21 | #define __OSDEP_SERVICE_H_ | |
22 | ||
23 | #include <basic_types.h> | |
24 | ||
25 | #define _FAIL 0 | |
26 | #define _SUCCESS 1 | |
27 | #define RTW_RX_HANDLED 2 | |
28 | ||
f9f08d70 LF |
29 | #include <linux/spinlock.h> |
30 | #include <linux/compiler.h> | |
31 | #include <linux/kernel.h> | |
32 | #include <linux/errno.h> | |
f9f08d70 LF |
33 | #include <linux/slab.h> |
34 | #include <linux/module.h> | |
35 | #include <linux/kref.h> | |
36 | #include <linux/netdevice.h> | |
37 | #include <linux/skbuff.h> | |
38 | #include <linux/circ_buf.h> | |
39 | #include <linux/uaccess.h> | |
40 | #include <asm/byteorder.h> | |
41 | #include <linux/atomic.h> | |
42 | #include <linux/io.h> | |
43 | #include <linux/semaphore.h> | |
44 | #include <linux/sem.h> | |
45 | #include <linux/sched.h> | |
46 | #include <linux/etherdevice.h> | |
47 | #include <linux/wireless.h> | |
48 | #include <net/iw_handler.h> | |
49 | #include <linux/if_arp.h> | |
50 | #include <linux/rtnetlink.h> | |
51 | #include <linux/delay.h> | |
52 | #include <linux/proc_fs.h> /* Necessary because we use the proc fs */ | |
53 | #include <linux/interrupt.h> /* for struct tasklet_struct */ | |
54 | #include <linux/ip.h> | |
55 | #include <linux/kthread.h> | |
56 | ||
57 | #include <linux/usb.h> | |
58 | #include <linux/usb/ch9.h> | |
59 | ||
60 | struct __queue { | |
61 | struct list_head queue; | |
62 | spinlock_t lock; | |
63 | }; | |
64 | ||
65 | #define thread_exit() complete_and_exit(NULL, 0) | |
66 | ||
67 | static inline struct list_head *get_next(struct list_head *list) | |
68 | { | |
69 | return list->next; | |
70 | } | |
71 | ||
72 | static inline struct list_head *get_list_head(struct __queue *queue) | |
73 | { | |
74 | return (&(queue->queue)); | |
75 | } | |
76 | ||
77 | ||
78 | #define LIST_CONTAINOR(ptr, type, member) \ | |
79 | ((type *)((char *)(ptr)-(size_t)(&((type *)0)->member))) | |
80 | ||
81 | ||
82 | static inline void _enter_critical(spinlock_t *plock, unsigned long *pirqL) | |
83 | { | |
84 | spin_lock_irqsave(plock, *pirqL); | |
85 | } | |
86 | ||
87 | static inline void _exit_critical(spinlock_t *plock, unsigned long *pirqL) | |
88 | { | |
89 | spin_unlock_irqrestore(plock, *pirqL); | |
90 | } | |
91 | ||
92 | static inline void _enter_critical_ex(spinlock_t *plock, unsigned long *pirqL) | |
93 | { | |
94 | spin_lock_irqsave(plock, *pirqL); | |
95 | } | |
96 | ||
97 | static inline void _exit_critical_ex(spinlock_t *plock, unsigned long *pirqL) | |
98 | { | |
99 | spin_unlock_irqrestore(plock, *pirqL); | |
100 | } | |
101 | ||
102 | static inline void _enter_critical_bh(spinlock_t *plock, unsigned long *pirqL) | |
103 | { | |
104 | spin_lock_bh(plock); | |
105 | } | |
106 | ||
107 | static inline void _exit_critical_bh(spinlock_t *plock, unsigned long *pirqL) | |
108 | { | |
109 | spin_unlock_bh(plock); | |
110 | } | |
111 | ||
112 | static inline int _enter_critical_mutex(struct mutex *pmutex, unsigned long *pirqL) | |
113 | { | |
114 | int ret; | |
115 | ||
116 | ret = mutex_lock_interruptible(pmutex); | |
117 | return ret; | |
118 | } | |
119 | ||
120 | ||
121 | static inline void _exit_critical_mutex(struct mutex *pmutex, unsigned long *pirqL) | |
122 | { | |
123 | mutex_unlock(pmutex); | |
124 | } | |
125 | ||
126 | static inline void rtw_list_delete(struct list_head *plist) | |
127 | { | |
128 | list_del_init(plist); | |
129 | } | |
130 | ||
131 | static inline void _init_timer(struct timer_list *ptimer,struct net_device *nic_hdl,void *pfunc,void* cntx) | |
132 | { | |
133 | ptimer->function = pfunc; | |
134 | ptimer->data = (unsigned long)cntx; | |
135 | init_timer(ptimer); | |
136 | } | |
137 | ||
138 | static inline void _set_timer(struct timer_list *ptimer,u32 delay_time) | |
139 | { | |
140 | mod_timer(ptimer , (jiffies+(delay_time*HZ/1000))); | |
141 | } | |
142 | ||
143 | static inline void _cancel_timer(struct timer_list *ptimer,u8 *bcancelled) | |
144 | { | |
145 | del_timer_sync(ptimer); | |
146 | *bcancelled= true;/* true ==1; false==0 */ | |
147 | } | |
148 | ||
149 | #define RTW_TIMER_HDL_ARGS void *FunctionContext | |
150 | #define RTW_TIMER_HDL_NAME(name) rtw_##name##_timer_hdl | |
151 | #define RTW_DECLARE_TIMER_HDL(name) void RTW_TIMER_HDL_NAME(name)(RTW_TIMER_HDL_ARGS) | |
152 | ||
153 | static inline void _init_workitem(struct work_struct *pwork, void *pfunc, void * cntx) | |
154 | { | |
155 | INIT_WORK(pwork, pfunc); | |
156 | } | |
157 | ||
158 | static inline void _set_workitem(struct work_struct *pwork) | |
159 | { | |
160 | schedule_work(pwork); | |
161 | } | |
162 | ||
163 | static inline void _cancel_workitem_sync(struct work_struct *pwork) | |
164 | { | |
165 | cancel_work_sync(pwork); | |
166 | } | |
167 | /* */ | |
168 | /* Global Mutex: can only be used at PASSIVE level. */ | |
169 | /* */ | |
170 | ||
171 | #define ACQUIRE_GLOBAL_MUTEX(_MutexCounter) \ | |
172 | { \ | |
173 | while (atomic_inc_return((atomic_t *)&(_MutexCounter)) != 1)\ | |
174 | { \ | |
175 | atomic_dec((atomic_t *)&(_MutexCounter)); \ | |
176 | msleep(10); \ | |
177 | } \ | |
178 | } | |
179 | ||
180 | #define RELEASE_GLOBAL_MUTEX(_MutexCounter) \ | |
181 | { \ | |
182 | atomic_dec((atomic_t *)&(_MutexCounter)); \ | |
183 | } | |
184 | ||
185 | static inline int rtw_netif_queue_stopped(struct net_device *pnetdev) | |
186 | { | |
187 | return netif_tx_queue_stopped(netdev_get_tx_queue(pnetdev, 0)) && | |
188 | netif_tx_queue_stopped(netdev_get_tx_queue(pnetdev, 1)) && | |
189 | netif_tx_queue_stopped(netdev_get_tx_queue(pnetdev, 2)) && | |
190 | netif_tx_queue_stopped(netdev_get_tx_queue(pnetdev, 3)); | |
191 | } | |
192 | ||
193 | static inline void rtw_netif_wake_queue(struct net_device *pnetdev) | |
194 | { | |
195 | netif_tx_wake_all_queues(pnetdev); | |
196 | } | |
197 | ||
198 | static inline void rtw_netif_start_queue(struct net_device *pnetdev) | |
199 | { | |
200 | netif_tx_start_all_queues(pnetdev); | |
201 | } | |
202 | ||
203 | static inline void rtw_netif_stop_queue(struct net_device *pnetdev) | |
204 | { | |
205 | netif_tx_stop_all_queues(pnetdev); | |
206 | } | |
207 | ||
208 | #ifndef BIT | |
209 | #define BIT(x) ( 1 << (x)) | |
210 | #endif | |
211 | ||
212 | #define BIT0 0x00000001 | |
213 | #define BIT1 0x00000002 | |
214 | #define BIT2 0x00000004 | |
215 | #define BIT3 0x00000008 | |
216 | #define BIT4 0x00000010 | |
217 | #define BIT5 0x00000020 | |
218 | #define BIT6 0x00000040 | |
219 | #define BIT7 0x00000080 | |
220 | #define BIT8 0x00000100 | |
221 | #define BIT9 0x00000200 | |
222 | #define BIT10 0x00000400 | |
223 | #define BIT11 0x00000800 | |
224 | #define BIT12 0x00001000 | |
225 | #define BIT13 0x00002000 | |
226 | #define BIT14 0x00004000 | |
227 | #define BIT15 0x00008000 | |
228 | #define BIT16 0x00010000 | |
229 | #define BIT17 0x00020000 | |
230 | #define BIT18 0x00040000 | |
231 | #define BIT19 0x00080000 | |
232 | #define BIT20 0x00100000 | |
233 | #define BIT21 0x00200000 | |
234 | #define BIT22 0x00400000 | |
235 | #define BIT23 0x00800000 | |
236 | #define BIT24 0x01000000 | |
237 | #define BIT25 0x02000000 | |
238 | #define BIT26 0x04000000 | |
239 | #define BIT27 0x08000000 | |
240 | #define BIT28 0x10000000 | |
241 | #define BIT29 0x20000000 | |
242 | #define BIT30 0x40000000 | |
243 | #define BIT31 0x80000000 | |
244 | #define BIT32 0x0100000000 | |
245 | #define BIT33 0x0200000000 | |
246 | #define BIT34 0x0400000000 | |
247 | #define BIT35 0x0800000000 | |
248 | #define BIT36 0x1000000000 | |
249 | ||
250 | extern int RTW_STATUS_CODE(int error_code); | |
251 | ||
252 | /* flags used for rtw_update_mem_stat() */ | |
253 | enum { | |
254 | MEM_STAT_VIR_ALLOC_SUCCESS, | |
255 | MEM_STAT_VIR_ALLOC_FAIL, | |
256 | MEM_STAT_VIR_FREE, | |
257 | MEM_STAT_PHY_ALLOC_SUCCESS, | |
258 | MEM_STAT_PHY_ALLOC_FAIL, | |
259 | MEM_STAT_PHY_FREE, | |
260 | MEM_STAT_TX, /* used to distinguish TX/RX, asigned from caller */ | |
261 | MEM_STAT_TX_ALLOC_SUCCESS, | |
262 | MEM_STAT_TX_ALLOC_FAIL, | |
263 | MEM_STAT_TX_FREE, | |
264 | MEM_STAT_RX, /* used to distinguish TX/RX, asigned from caller */ | |
265 | MEM_STAT_RX_ALLOC_SUCCESS, | |
266 | MEM_STAT_RX_ALLOC_FAIL, | |
267 | MEM_STAT_RX_FREE | |
268 | }; | |
269 | ||
270 | extern unsigned char MCS_rate_2R[16]; | |
271 | extern unsigned char MCS_rate_1R[16]; | |
272 | extern unsigned char RTW_WPA_OUI[]; | |
273 | extern unsigned char WPA_TKIP_CIPHER[4]; | |
274 | extern unsigned char RSN_TKIP_CIPHER[4]; | |
275 | ||
276 | #define rtw_update_mem_stat(flag, sz) do {} while (0) | |
277 | u8 *_rtw_vmalloc(u32 sz); | |
278 | u8 *_rtw_zvmalloc(u32 sz); | |
279 | void _rtw_vmfree(u8 *pbuf, u32 sz); | |
280 | u8 *_rtw_zmalloc(u32 sz); | |
281 | u8 *_rtw_malloc(u32 sz); | |
282 | void _rtw_mfree(u8 *pbuf, u32 sz); | |
283 | #define rtw_vmalloc(sz) _rtw_vmalloc((sz)) | |
284 | #define rtw_zvmalloc(sz) _rtw_zvmalloc((sz)) | |
285 | #define rtw_vmfree(pbuf, sz) _rtw_vmfree((pbuf), (sz)) | |
286 | #define rtw_malloc(sz) _rtw_malloc((sz)) | |
287 | #define rtw_zmalloc(sz) _rtw_zmalloc((sz)) | |
288 | #define rtw_mfree(pbuf, sz) _rtw_mfree((pbuf), (sz)) | |
289 | ||
290 | void *rtw_malloc2d(int h, int w, int size); | |
291 | void rtw_mfree2d(void *pbuf, int h, int w, int size); | |
292 | ||
293 | void _rtw_memcpy(void *dec, void *sour, u32 sz); | |
294 | int _rtw_memcmp(void *dst, void *src, u32 sz); | |
295 | void _rtw_memset(void *pbuf, int c, u32 sz); | |
296 | ||
297 | void _rtw_init_listhead(struct list_head *list); | |
298 | u32 rtw_is_list_empty(struct list_head *phead); | |
299 | void rtw_list_insert_head(struct list_head *plist, struct list_head *phead); | |
300 | void rtw_list_insert_tail(struct list_head *plist, struct list_head *phead); | |
301 | void rtw_list_delete(struct list_head *plist); | |
302 | ||
303 | void _rtw_init_sema(struct semaphore *sema, int init_val); | |
304 | void _rtw_free_sema(struct semaphore *sema); | |
305 | void _rtw_up_sema(struct semaphore *sema); | |
306 | u32 _rtw_down_sema(struct semaphore *sema); | |
307 | void _rtw_mutex_init(struct mutex *pmutex); | |
308 | void _rtw_mutex_free(struct mutex *pmutex); | |
309 | void _rtw_spinlock_init(spinlock_t *plock); | |
310 | void _rtw_spinlock_free(spinlock_t *plock); | |
311 | ||
312 | void _rtw_init_queue(struct __queue *pqueue); | |
313 | u32 _rtw_queue_empty(struct __queue *pqueue); | |
314 | u32 rtw_end_of_queue_search(struct list_head *queue, struct list_head *pelement); | |
315 | ||
316 | u32 rtw_get_current_time(void); | |
317 | u32 rtw_systime_to_ms(u32 systime); | |
318 | u32 rtw_ms_to_systime(u32 ms); | |
319 | s32 rtw_get_passing_time_ms(u32 start); | |
320 | s32 rtw_get_time_interval_ms(u32 start, u32 end); | |
321 | ||
322 | void rtw_sleep_schedulable(int ms); | |
323 | ||
324 | void rtw_msleep_os(int ms); | |
325 | void rtw_usleep_os(int us); | |
326 | ||
327 | u32 rtw_atoi(u8 *s); | |
328 | ||
329 | void rtw_mdelay_os(int ms); | |
330 | void rtw_udelay_os(int us); | |
331 | ||
332 | void rtw_yield_os(void); | |
333 | ||
334 | static inline unsigned char _cancel_timer_ex(struct timer_list *ptimer) | |
335 | { | |
336 | return del_timer_sync(ptimer); | |
337 | } | |
338 | ||
339 | static __inline void thread_enter(char *name) | |
340 | { | |
341 | #ifdef daemonize | |
342 | daemonize("%s", name); | |
343 | #endif | |
344 | allow_signal(SIGTERM); | |
345 | } | |
346 | ||
347 | static inline void flush_signals_thread(void) | |
348 | { | |
349 | if (signal_pending (current)) | |
350 | flush_signals(current); | |
351 | } | |
352 | ||
353 | static inline int res_to_status(int res) | |
354 | { | |
355 | return res; | |
356 | } | |
357 | ||
358 | #define _RND(sz, r) ((((sz)+((r)-1))/(r))*(r)) | |
359 | #define RND4(x) (((x >> 2) + (((x & 3) == 0) ? 0: 1)) << 2) | |
360 | ||
361 | static inline u32 _RND4(u32 sz) | |
362 | { | |
363 | u32 val; | |
364 | ||
365 | val = ((sz >> 2) + ((sz & 3) ? 1: 0)) << 2; | |
366 | return val; | |
367 | } | |
368 | ||
369 | static inline u32 _RND8(u32 sz) | |
370 | { | |
371 | u32 val; | |
372 | ||
373 | val = ((sz >> 3) + ((sz & 7) ? 1: 0)) << 3; | |
374 | return val; | |
375 | } | |
376 | ||
377 | static inline u32 _RND128(u32 sz) | |
378 | { | |
379 | u32 val; | |
380 | ||
381 | val = ((sz >> 7) + ((sz & 127) ? 1: 0)) << 7; | |
382 | return val; | |
383 | } | |
384 | ||
385 | static inline u32 _RND256(u32 sz) | |
386 | { | |
387 | u32 val; | |
388 | ||
389 | val = ((sz >> 8) + ((sz & 255) ? 1: 0)) << 8; | |
390 | return val; | |
391 | } | |
392 | ||
393 | static inline u32 _RND512(u32 sz) | |
394 | { | |
395 | u32 val; | |
396 | ||
397 | val = ((sz >> 9) + ((sz & 511) ? 1: 0)) << 9; | |
398 | return val; | |
399 | } | |
400 | ||
401 | static inline u32 bitshift(u32 bitmask) | |
402 | { | |
403 | u32 i; | |
404 | ||
405 | for (i = 0; i <= 31; i++) | |
406 | if (((bitmask>>i) & 0x1) == 1) break; | |
407 | return i; | |
408 | } | |
409 | ||
410 | /* limitation of path length */ | |
411 | #define PATH_LENGTH_MAX PATH_MAX | |
412 | ||
413 | void rtw_suspend_lock_init(void); | |
414 | void rtw_suspend_lock_uninit(void); | |
415 | void rtw_lock_suspend(void); | |
416 | void rtw_unlock_suspend(void); | |
417 | ||
418 | /* Atomic integer operations */ | |
419 | #define ATOMIC_T atomic_t | |
420 | ||
421 | void ATOMIC_SET(ATOMIC_T *v, int i); | |
422 | int ATOMIC_READ(ATOMIC_T *v); | |
423 | void ATOMIC_ADD(ATOMIC_T *v, int i); | |
424 | void ATOMIC_SUB(ATOMIC_T *v, int i); | |
425 | void ATOMIC_INC(ATOMIC_T *v); | |
426 | void ATOMIC_DEC(ATOMIC_T *v); | |
427 | int ATOMIC_ADD_RETURN(ATOMIC_T *v, int i); | |
428 | int ATOMIC_SUB_RETURN(ATOMIC_T *v, int i); | |
429 | int ATOMIC_INC_RETURN(ATOMIC_T *v); | |
430 | int ATOMIC_DEC_RETURN(ATOMIC_T *v); | |
431 | ||
f9f08d70 LF |
432 | struct rtw_netdev_priv_indicator { |
433 | void *priv; | |
434 | u32 sizeof_priv; | |
435 | }; | |
436 | struct net_device *rtw_alloc_etherdev_with_old_priv(int sizeof_priv, | |
437 | void *old_priv); | |
438 | struct net_device *rtw_alloc_etherdev(int sizeof_priv); | |
439 | ||
440 | #define rtw_netdev_priv(netdev) \ | |
441 | (((struct rtw_netdev_priv_indicator *)netdev_priv(netdev))->priv) | |
442 | void rtw_free_netdev(struct net_device *netdev); | |
443 | ||
444 | #define NDEV_FMT "%s" | |
445 | #define NDEV_ARG(ndev) ndev->name | |
446 | #define ADPT_FMT "%s" | |
447 | #define ADPT_ARG(adapter) adapter->pnetdev->name | |
448 | #define FUNC_NDEV_FMT "%s(%s)" | |
449 | #define FUNC_NDEV_ARG(ndev) __func__, ndev->name | |
450 | #define FUNC_ADPT_FMT "%s(%s)" | |
451 | #define FUNC_ADPT_ARG(adapter) __func__, adapter->pnetdev->name | |
452 | ||
453 | #define rtw_signal_process(pid, sig) kill_pid(find_vpid((pid)),(sig), 1) | |
454 | ||
455 | u64 rtw_modular64(u64 x, u64 y); | |
456 | u64 rtw_division64(u64 x, u64 y); | |
457 | ||
458 | /* Macros for handling unaligned memory accesses */ | |
459 | ||
460 | #define RTW_GET_BE16(a) ((u16) (((a)[0] << 8) | (a)[1])) | |
461 | #define RTW_PUT_BE16(a, val) \ | |
462 | do { \ | |
463 | (a)[0] = ((u16) (val)) >> 8; \ | |
464 | (a)[1] = ((u16) (val)) & 0xff; \ | |
465 | } while (0) | |
466 | ||
467 | #define RTW_GET_LE16(a) ((u16) (((a)[1] << 8) | (a)[0])) | |
468 | #define RTW_PUT_LE16(a, val) \ | |
469 | do { \ | |
470 | (a)[1] = ((u16) (val)) >> 8; \ | |
471 | (a)[0] = ((u16) (val)) & 0xff; \ | |
472 | } while (0) | |
473 | ||
474 | #define RTW_GET_BE24(a) ((((u32) (a)[0]) << 16) | (((u32) (a)[1]) << 8) | \ | |
475 | ((u32) (a)[2])) | |
476 | #define RTW_PUT_BE24(a, val) \ | |
477 | do { \ | |
478 | (a)[0] = (u8) ((((u32) (val)) >> 16) & 0xff); \ | |
479 | (a)[1] = (u8) ((((u32) (val)) >> 8) & 0xff); \ | |
480 | (a)[2] = (u8) (((u32) (val)) & 0xff); \ | |
481 | } while (0) | |
482 | ||
483 | #define RTW_GET_BE32(a) ((((u32) (a)[0]) << 24) | (((u32) (a)[1]) << 16) | \ | |
484 | (((u32) (a)[2]) << 8) | ((u32) (a)[3])) | |
485 | #define RTW_PUT_BE32(a, val) \ | |
486 | do { \ | |
487 | (a)[0] = (u8) ((((u32) (val)) >> 24) & 0xff); \ | |
488 | (a)[1] = (u8) ((((u32) (val)) >> 16) & 0xff); \ | |
489 | (a)[2] = (u8) ((((u32) (val)) >> 8) & 0xff); \ | |
490 | (a)[3] = (u8) (((u32) (val)) & 0xff); \ | |
491 | } while (0) | |
492 | ||
493 | #define RTW_GET_LE32(a) ((((u32) (a)[3]) << 24) | (((u32) (a)[2]) << 16) | \ | |
494 | (((u32) (a)[1]) << 8) | ((u32) (a)[0])) | |
495 | #define RTW_PUT_LE32(a, val) \ | |
496 | do { \ | |
497 | (a)[3] = (u8) ((((u32) (val)) >> 24) & 0xff); \ | |
498 | (a)[2] = (u8) ((((u32) (val)) >> 16) & 0xff); \ | |
499 | (a)[1] = (u8) ((((u32) (val)) >> 8) & 0xff); \ | |
500 | (a)[0] = (u8) (((u32) (val)) & 0xff); \ | |
501 | } while (0) | |
502 | ||
503 | #define RTW_GET_BE64(a) ((((u64) (a)[0]) << 56) | (((u64) (a)[1]) << 48) | \ | |
504 | (((u64) (a)[2]) << 40) | (((u64) (a)[3]) << 32) | \ | |
505 | (((u64) (a)[4]) << 24) | (((u64) (a)[5]) << 16) | \ | |
506 | (((u64) (a)[6]) << 8) | ((u64) (a)[7])) | |
507 | #define RTW_PUT_BE64(a, val) \ | |
508 | do { \ | |
509 | (a)[0] = (u8) (((u64) (val)) >> 56); \ | |
510 | (a)[1] = (u8) (((u64) (val)) >> 48); \ | |
511 | (a)[2] = (u8) (((u64) (val)) >> 40); \ | |
512 | (a)[3] = (u8) (((u64) (val)) >> 32); \ | |
513 | (a)[4] = (u8) (((u64) (val)) >> 24); \ | |
514 | (a)[5] = (u8) (((u64) (val)) >> 16); \ | |
515 | (a)[6] = (u8) (((u64) (val)) >> 8); \ | |
516 | (a)[7] = (u8) (((u64) (val)) & 0xff); \ | |
517 | } while (0) | |
518 | ||
519 | #define RTW_GET_LE64(a) ((((u64) (a)[7]) << 56) | (((u64) (a)[6]) << 48) | \ | |
520 | (((u64) (a)[5]) << 40) | (((u64) (a)[4]) << 32) | \ | |
521 | (((u64) (a)[3]) << 24) | (((u64) (a)[2]) << 16) | \ | |
522 | (((u64) (a)[1]) << 8) | ((u64) (a)[0])) | |
523 | ||
524 | void rtw_buf_free(u8 **buf, u32 *buf_len); | |
525 | void rtw_buf_update(u8 **buf, u32 *buf_len, u8 *src, u32 src_len); | |
526 | ||
527 | struct rtw_cbuf { | |
528 | u32 write; | |
529 | u32 read; | |
530 | u32 size; | |
531 | void *bufs[0]; | |
532 | }; | |
533 | ||
534 | bool rtw_cbuf_full(struct rtw_cbuf *cbuf); | |
535 | bool rtw_cbuf_empty(struct rtw_cbuf *cbuf); | |
536 | bool rtw_cbuf_push(struct rtw_cbuf *cbuf, void *buf); | |
537 | void *rtw_cbuf_pop(struct rtw_cbuf *cbuf); | |
538 | struct rtw_cbuf *rtw_cbuf_alloc(u32 size); | |
539 | int wifirate2_ratetbl_inx(unsigned char rate); | |
540 | ||
541 | #endif |