diff options
Diffstat (limited to 'drivers/net/wireless/bcmdhd/include/linux_osl.h')
-rw-r--r-- | drivers/net/wireless/bcmdhd/include/linux_osl.h | 431 |
1 files changed, 431 insertions, 0 deletions
diff --git a/drivers/net/wireless/bcmdhd/include/linux_osl.h b/drivers/net/wireless/bcmdhd/include/linux_osl.h new file mode 100644 index 00000000000..7f92966d977 --- /dev/null +++ b/drivers/net/wireless/bcmdhd/include/linux_osl.h | |||
@@ -0,0 +1,431 @@ | |||
1 | /* | ||
2 | * Linux OS Independent Layer | ||
3 | * | ||
4 | * Copyright (C) 1999-2011, Broadcom Corporation | ||
5 | * | ||
6 | * Unless you and Broadcom execute a separate written software license | ||
7 | * agreement governing use of this software, this software is licensed to you | ||
8 | * under the terms of the GNU General Public License version 2 (the "GPL"), | ||
9 | * available at http://www.broadcom.com/licenses/GPLv2.php, with the | ||
10 | * following added to such license: | ||
11 | * | ||
12 | * As a special exception, the copyright holders of this software give you | ||
13 | * permission to link this software with independent modules, and to copy and | ||
14 | * distribute the resulting executable under terms of your choice, provided that | ||
15 | * you also meet, for each linked independent module, the terms and conditions of | ||
16 | * the license of that module. An independent module is a module which is not | ||
17 | * derived from this software. The special exception does not apply to any | ||
18 | * modifications of the software. | ||
19 | * | ||
20 | * Notwithstanding the above, under no circumstances may you combine this | ||
21 | * software in any way with any other Broadcom software provided under a license | ||
22 | * other than the GPL, without Broadcom's express prior written consent. | ||
23 | * | ||
24 | * $Id: linux_osl.h 301794 2011-12-08 20:41:35Z $ | ||
25 | */ | ||
26 | |||
27 | |||
28 | #ifndef _linux_osl_h_ | ||
29 | #define _linux_osl_h_ | ||
30 | |||
31 | #include <typedefs.h> | ||
32 | |||
33 | |||
34 | extern void * osl_os_open_image(char * filename); | ||
35 | extern int osl_os_get_image_block(char * buf, int len, void * image); | ||
36 | extern void osl_os_close_image(void * image); | ||
37 | |||
38 | |||
39 | #ifdef BCMDRIVER | ||
40 | |||
41 | |||
42 | extern osl_t *osl_attach(void *pdev, uint bustype, bool pkttag); | ||
43 | extern void osl_detach(osl_t *osh); | ||
44 | |||
45 | |||
46 | extern uint32 g_assert_type; | ||
47 | |||
48 | |||
49 | #if defined(BCMASSERT_LOG) | ||
50 | #define ASSERT(exp) \ | ||
51 | do { if (!(exp)) osl_assert(#exp, __FILE__, __LINE__); } while (0) | ||
52 | extern void osl_assert(char *exp, char *file, int line); | ||
53 | #else | ||
54 | #ifdef __GNUC__ | ||
55 | #define GCC_VERSION \ | ||
56 | (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) | ||
57 | #if GCC_VERSION > 30100 | ||
58 | #define ASSERT(exp) do {} while (0) | ||
59 | #else | ||
60 | |||
61 | #define ASSERT(exp) | ||
62 | #endif | ||
63 | #endif | ||
64 | #endif | ||
65 | |||
66 | |||
67 | #define OSL_DELAY(usec) osl_delay(usec) | ||
68 | extern void osl_delay(uint usec); | ||
69 | |||
70 | #define OSL_PCMCIA_READ_ATTR(osh, offset, buf, size) \ | ||
71 | osl_pcmcia_read_attr((osh), (offset), (buf), (size)) | ||
72 | #define OSL_PCMCIA_WRITE_ATTR(osh, offset, buf, size) \ | ||
73 | osl_pcmcia_write_attr((osh), (offset), (buf), (size)) | ||
74 | extern void osl_pcmcia_read_attr(osl_t *osh, uint offset, void *buf, int size); | ||
75 | extern void osl_pcmcia_write_attr(osl_t *osh, uint offset, void *buf, int size); | ||
76 | |||
77 | |||
78 | #define OSL_PCI_READ_CONFIG(osh, offset, size) \ | ||
79 | osl_pci_read_config((osh), (offset), (size)) | ||
80 | #define OSL_PCI_WRITE_CONFIG(osh, offset, size, val) \ | ||
81 | osl_pci_write_config((osh), (offset), (size), (val)) | ||
82 | extern uint32 osl_pci_read_config(osl_t *osh, uint offset, uint size); | ||
83 | extern void osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val); | ||
84 | |||
85 | |||
86 | #define OSL_PCI_BUS(osh) osl_pci_bus(osh) | ||
87 | #define OSL_PCI_SLOT(osh) osl_pci_slot(osh) | ||
88 | extern uint osl_pci_bus(osl_t *osh); | ||
89 | extern uint osl_pci_slot(osl_t *osh); | ||
90 | |||
91 | |||
92 | typedef struct { | ||
93 | bool pkttag; | ||
94 | uint pktalloced; | ||
95 | bool mmbus; | ||
96 | pktfree_cb_fn_t tx_fn; | ||
97 | void *tx_ctx; | ||
98 | } osl_pubinfo_t; | ||
99 | |||
100 | #define PKTFREESETCB(osh, _tx_fn, _tx_ctx) \ | ||
101 | do { \ | ||
102 | ((osl_pubinfo_t*)osh)->tx_fn = _tx_fn; \ | ||
103 | ((osl_pubinfo_t*)osh)->tx_ctx = _tx_ctx; \ | ||
104 | } while (0) | ||
105 | |||
106 | |||
107 | |||
108 | #define BUS_SWAP32(v) (v) | ||
109 | |||
110 | #define MALLOC(osh, size) osl_malloc((osh), (size)) | ||
111 | #define MFREE(osh, addr, size) osl_mfree((osh), (addr), (size)) | ||
112 | #define MALLOCED(osh) osl_malloced((osh)) | ||
113 | extern void *osl_malloc(osl_t *osh, uint size); | ||
114 | extern void osl_mfree(osl_t *osh, void *addr, uint size); | ||
115 | extern uint osl_malloced(osl_t *osh); | ||
116 | |||
117 | #define NATIVE_MALLOC(osh, size) kmalloc(size, GFP_ATOMIC) | ||
118 | #define NATIVE_MFREE(osh, addr, size) kfree(addr) | ||
119 | |||
120 | #define MALLOC_FAILED(osh) osl_malloc_failed((osh)) | ||
121 | extern uint osl_malloc_failed(osl_t *osh); | ||
122 | |||
123 | |||
124 | #define DMA_CONSISTENT_ALIGN osl_dma_consistent_align() | ||
125 | #define DMA_ALLOC_CONSISTENT(osh, size, align, tot, pap, dmah) \ | ||
126 | osl_dma_alloc_consistent((osh), (size), (align), (tot), (pap)) | ||
127 | #define DMA_FREE_CONSISTENT(osh, va, size, pa, dmah) \ | ||
128 | osl_dma_free_consistent((osh), (void*)(va), (size), (pa)) | ||
129 | extern uint osl_dma_consistent_align(void); | ||
130 | extern void *osl_dma_alloc_consistent(osl_t *osh, uint size, uint16 align, uint *tot, ulong *pap); | ||
131 | extern void osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa); | ||
132 | |||
133 | |||
134 | #define DMA_TX 1 | ||
135 | #define DMA_RX 2 | ||
136 | |||
137 | |||
138 | #define DMA_MAP(osh, va, size, direction, p, dmah) \ | ||
139 | osl_dma_map((osh), (va), (size), (direction)) | ||
140 | #define DMA_UNMAP(osh, pa, size, direction, p, dmah) \ | ||
141 | osl_dma_unmap((osh), (pa), (size), (direction)) | ||
142 | extern uint osl_dma_map(osl_t *osh, void *va, uint size, int direction); | ||
143 | extern void osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction); | ||
144 | |||
145 | |||
146 | #define OSL_DMADDRWIDTH(osh, addrwidth) do {} while (0) | ||
147 | |||
148 | |||
149 | #include <bcmsdh.h> | ||
150 | #define OSL_WRITE_REG(osh, r, v) (bcmsdh_reg_write(NULL, (uintptr)(r), sizeof(*(r)), (v))) | ||
151 | #define OSL_READ_REG(osh, r) (bcmsdh_reg_read(NULL, (uintptr)(r), sizeof(*(r)))) | ||
152 | |||
153 | #define SELECT_BUS_WRITE(osh, mmap_op, bus_op) if (((osl_pubinfo_t*)(osh))->mmbus) \ | ||
154 | mmap_op else bus_op | ||
155 | #define SELECT_BUS_READ(osh, mmap_op, bus_op) (((osl_pubinfo_t*)(osh))->mmbus) ? \ | ||
156 | mmap_op : bus_op | ||
157 | |||
158 | #define OSL_ERROR(bcmerror) osl_error(bcmerror) | ||
159 | extern int osl_error(int bcmerror); | ||
160 | |||
161 | |||
162 | #define PKTBUFSZ 2048 | ||
163 | |||
164 | |||
165 | |||
166 | #define OSL_SYSUPTIME() ((uint32)jiffies_to_msecs(jiffies)) | ||
167 | #define printf(fmt, args...) printk(fmt , ## args) | ||
168 | #include <linux/kernel.h> | ||
169 | #include <linux/string.h> | ||
170 | |||
171 | #define bcopy(src, dst, len) memcpy((dst), (src), (len)) | ||
172 | #define bcmp(b1, b2, len) memcmp((b1), (b2), (len)) | ||
173 | #define bzero(b, len) memset((b), '\0', (len)) | ||
174 | |||
175 | |||
176 | |||
177 | #ifndef __mips__ | ||
178 | #define R_REG(osh, r) (\ | ||
179 | SELECT_BUS_READ(osh, sizeof(*(r)) == sizeof(uint8) ? readb((volatile uint8*)(r)) : \ | ||
180 | sizeof(*(r)) == sizeof(uint16) ? readw((volatile uint16*)(r)) : \ | ||
181 | readl((volatile uint32*)(r)), OSL_READ_REG(osh, r)) \ | ||
182 | ) | ||
183 | #else | ||
184 | #define R_REG(osh, r) (\ | ||
185 | SELECT_BUS_READ(osh, \ | ||
186 | ({ \ | ||
187 | __typeof(*(r)) __osl_v; \ | ||
188 | __asm__ __volatile__("sync"); \ | ||
189 | switch (sizeof(*(r))) { \ | ||
190 | case sizeof(uint8): __osl_v = \ | ||
191 | readb((volatile uint8*)(r)); break; \ | ||
192 | case sizeof(uint16): __osl_v = \ | ||
193 | readw((volatile uint16*)(r)); break; \ | ||
194 | case sizeof(uint32): __osl_v = \ | ||
195 | readl((volatile uint32*)(r)); break; \ | ||
196 | } \ | ||
197 | __asm__ __volatile__("sync"); \ | ||
198 | __osl_v; \ | ||
199 | }), \ | ||
200 | ({ \ | ||
201 | __typeof(*(r)) __osl_v; \ | ||
202 | __asm__ __volatile__("sync"); \ | ||
203 | __osl_v = OSL_READ_REG(osh, r); \ | ||
204 | __asm__ __volatile__("sync"); \ | ||
205 | __osl_v; \ | ||
206 | })) \ | ||
207 | ) | ||
208 | #endif | ||
209 | |||
210 | #define W_REG(osh, r, v) do { \ | ||
211 | SELECT_BUS_WRITE(osh, \ | ||
212 | switch (sizeof(*(r))) { \ | ||
213 | case sizeof(uint8): writeb((uint8)(v), (volatile uint8*)(r)); break; \ | ||
214 | case sizeof(uint16): writew((uint16)(v), (volatile uint16*)(r)); break; \ | ||
215 | case sizeof(uint32): writel((uint32)(v), (volatile uint32*)(r)); break; \ | ||
216 | }, \ | ||
217 | (OSL_WRITE_REG(osh, r, v))); \ | ||
218 | } while (0) | ||
219 | |||
220 | |||
221 | #define AND_REG(osh, r, v) W_REG(osh, (r), R_REG(osh, r) & (v)) | ||
222 | #define OR_REG(osh, r, v) W_REG(osh, (r), R_REG(osh, r) | (v)) | ||
223 | |||
224 | |||
225 | #define bcopy(src, dst, len) memcpy((dst), (src), (len)) | ||
226 | #define bcmp(b1, b2, len) memcmp((b1), (b2), (len)) | ||
227 | #define bzero(b, len) memset((b), '\0', (len)) | ||
228 | |||
229 | |||
230 | #ifdef __mips__ | ||
231 | #include <asm/addrspace.h> | ||
232 | #define OSL_UNCACHED(va) ((void *)KSEG1ADDR((va))) | ||
233 | #define OSL_CACHED(va) ((void *)KSEG0ADDR((va))) | ||
234 | #else | ||
235 | #define OSL_UNCACHED(va) ((void *)va) | ||
236 | #define OSL_CACHED(va) ((void *)va) | ||
237 | #endif | ||
238 | |||
239 | |||
240 | #if defined(__i386__) | ||
241 | #define OSL_GETCYCLES(x) rdtscl((x)) | ||
242 | #else | ||
243 | #define OSL_GETCYCLES(x) ((x) = 0) | ||
244 | #endif | ||
245 | |||
246 | |||
247 | #define BUSPROBE(val, addr) ({ (val) = R_REG(NULL, (addr)); 0; }) | ||
248 | |||
249 | |||
250 | #if !defined(CONFIG_MMC_MSM7X00A) | ||
251 | #define REG_MAP(pa, size) ioremap_nocache((unsigned long)(pa), (unsigned long)(size)) | ||
252 | #else | ||
253 | #define REG_MAP(pa, size) (void *)(0) | ||
254 | #endif | ||
255 | #define REG_UNMAP(va) iounmap((va)) | ||
256 | |||
257 | |||
258 | #define R_SM(r) *(r) | ||
259 | #define W_SM(r, v) (*(r) = (v)) | ||
260 | #define BZERO_SM(r, len) memset((r), '\0', (len)) | ||
261 | |||
262 | |||
263 | #include <linuxver.h> | ||
264 | |||
265 | |||
266 | #define PKTGET(osh, len, send) osl_pktget((osh), (len)) | ||
267 | #define PKTDUP(osh, skb) osl_pktdup((osh), (skb)) | ||
268 | #define PKTLIST_DUMP(osh, buf) | ||
269 | #define PKTDBG_TRACE(osh, pkt, bit) | ||
270 | #define PKTFREE(osh, skb, send) osl_pktfree((osh), (skb), (send)) | ||
271 | #ifdef CONFIG_DHD_USE_STATIC_BUF | ||
272 | #define PKTGET_STATIC(osh, len, send) osl_pktget_static((osh), (len)) | ||
273 | #define PKTFREE_STATIC(osh, skb, send) osl_pktfree_static((osh), (skb), (send)) | ||
274 | #endif | ||
275 | #define PKTDATA(osh, skb) (((struct sk_buff*)(skb))->data) | ||
276 | #define PKTLEN(osh, skb) (((struct sk_buff*)(skb))->len) | ||
277 | #define PKTHEADROOM(osh, skb) (PKTDATA(osh, skb)-(((struct sk_buff*)(skb))->head)) | ||
278 | #define PKTTAILROOM(osh, skb) ((((struct sk_buff*)(skb))->end)-(((struct sk_buff*)(skb))->tail)) | ||
279 | #define PKTNEXT(osh, skb) (((struct sk_buff*)(skb))->next) | ||
280 | #define PKTSETNEXT(osh, skb, x) (((struct sk_buff*)(skb))->next = (struct sk_buff*)(x)) | ||
281 | #define PKTSETLEN(osh, skb, len) __skb_trim((struct sk_buff*)(skb), (len)) | ||
282 | #define PKTPUSH(osh, skb, bytes) skb_push((struct sk_buff*)(skb), (bytes)) | ||
283 | #define PKTPULL(osh, skb, bytes) skb_pull((struct sk_buff*)(skb), (bytes)) | ||
284 | #define PKTTAG(skb) ((void*)(((struct sk_buff*)(skb))->cb)) | ||
285 | #define PKTALLOCED(osh) ((osl_pubinfo_t *)(osh))->pktalloced | ||
286 | #define PKTSETPOOL(osh, skb, x, y) do {} while (0) | ||
287 | #define PKTPOOL(osh, skb) FALSE | ||
288 | #define PKTSHRINK(osh, m) (m) | ||
289 | |||
290 | #ifdef CTFPOOL | ||
291 | #define CTFPOOL_REFILL_THRESH 3 | ||
292 | typedef struct ctfpool { | ||
293 | void *head; | ||
294 | spinlock_t lock; | ||
295 | uint max_obj; | ||
296 | uint curr_obj; | ||
297 | uint obj_size; | ||
298 | uint refills; | ||
299 | uint fast_allocs; | ||
300 | uint fast_frees; | ||
301 | uint slow_allocs; | ||
302 | } ctfpool_t; | ||
303 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22) | ||
304 | #define FASTBUF (1 << 4) | ||
305 | #define CTFBUF (1 << 5) | ||
306 | #define PKTSETFAST(osh, skb) ((((struct sk_buff*)(skb))->mac_len) |= FASTBUF) | ||
307 | #define PKTCLRFAST(osh, skb) ((((struct sk_buff*)(skb))->mac_len) &= (~FASTBUF)) | ||
308 | #define PKTSETCTF(osh, skb) ((((struct sk_buff*)(skb))->mac_len) |= CTFBUF) | ||
309 | #define PKTCLRCTF(osh, skb) ((((struct sk_buff*)(skb))->mac_len) &= (~CTFBUF)) | ||
310 | #define PKTISFAST(osh, skb) ((((struct sk_buff*)(skb))->mac_len) & FASTBUF) | ||
311 | #define PKTISCTF(osh, skb) ((((struct sk_buff*)(skb))->mac_len) & CTFBUF) | ||
312 | #define PKTFAST(osh, skb) (((struct sk_buff*)(skb))->mac_len) | ||
313 | #else | ||
314 | #define FASTBUF (1 << 0) | ||
315 | #define CTFBUF (1 << 1) | ||
316 | #define PKTSETFAST(osh, skb) ((((struct sk_buff*)(skb))->__unused) |= FASTBUF) | ||
317 | #define PKTCLRFAST(osh, skb) ((((struct sk_buff*)(skb))->__unused) &= (~FASTBUF)) | ||
318 | #define PKTSETCTF(osh, skb) ((((struct sk_buff*)(skb))->__unused) |= CTFBUF) | ||
319 | #define PKTCLRCTF(osh, skb) ((((struct sk_buff*)(skb))->__unused) &= (~CTFBUF)) | ||
320 | #define PKTISFAST(osh, skb) ((((struct sk_buff*)(skb))->__unused) & FASTBUF) | ||
321 | #define PKTISCTF(osh, skb) ((((struct sk_buff*)(skb))->__unused) & CTFBUF) | ||
322 | #define PKTFAST(osh, skb) (((struct sk_buff*)(skb))->__unused) | ||
323 | #endif | ||
324 | |||
325 | #define CTFPOOLPTR(osh, skb) (((struct sk_buff*)(skb))->sk) | ||
326 | #define CTFPOOLHEAD(osh, skb) (((ctfpool_t *)((struct sk_buff*)(skb))->sk)->head) | ||
327 | |||
328 | extern void *osl_ctfpool_add(osl_t *osh); | ||
329 | extern void osl_ctfpool_replenish(osl_t *osh, uint thresh); | ||
330 | extern int32 osl_ctfpool_init(osl_t *osh, uint numobj, uint size); | ||
331 | extern void osl_ctfpool_cleanup(osl_t *osh); | ||
332 | extern void osl_ctfpool_stats(osl_t *osh, void *b); | ||
333 | #endif | ||
334 | |||
335 | #ifdef HNDCTF | ||
336 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22) | ||
337 | #define SKIPCT (1 << 6) | ||
338 | #define PKTSETSKIPCT(osh, skb) (((struct sk_buff*)(skb))->mac_len |= SKIPCT) | ||
339 | #define PKTCLRSKIPCT(osh, skb) (((struct sk_buff*)(skb))->mac_len &= (~SKIPCT)) | ||
340 | #define PKTSKIPCT(osh, skb) (((struct sk_buff*)(skb))->mac_len & SKIPCT) | ||
341 | #else | ||
342 | #define SKIPCT (1 << 2) | ||
343 | #define PKTSETSKIPCT(osh, skb) (((struct sk_buff*)(skb))->__unused |= SKIPCT) | ||
344 | #define PKTCLRSKIPCT(osh, skb) (((struct sk_buff*)(skb))->__unused &= (~SKIPCT)) | ||
345 | #define PKTSKIPCT(osh, skb) (((struct sk_buff*)(skb))->__unused & SKIPCT) | ||
346 | #endif | ||
347 | #else | ||
348 | #define PKTSETSKIPCT(osh, skb) | ||
349 | #define PKTCLRSKIPCT(osh, skb) | ||
350 | #define PKTSKIPCT(osh, skb) | ||
351 | #endif | ||
352 | |||
353 | extern void osl_pktfree(osl_t *osh, void *skb, bool send); | ||
354 | extern void *osl_pktget_static(osl_t *osh, uint len); | ||
355 | extern void osl_pktfree_static(osl_t *osh, void *skb, bool send); | ||
356 | |||
357 | extern void *osl_pktget(osl_t *osh, uint len); | ||
358 | extern void *osl_pktdup(osl_t *osh, void *skb); | ||
359 | |||
360 | |||
361 | static INLINE void * | ||
362 | osl_pkt_frmnative(osl_pubinfo_t *osh, void *pkt) | ||
363 | { | ||
364 | struct sk_buff *nskb; | ||
365 | |||
366 | if (osh->pkttag) | ||
367 | bzero((void*)((struct sk_buff*)pkt)->cb, OSL_PKTTAG_SZ); | ||
368 | |||
369 | |||
370 | for (nskb = (struct sk_buff *)pkt; nskb; nskb = nskb->next) { | ||
371 | osh->pktalloced++; | ||
372 | } | ||
373 | |||
374 | return (void *)pkt; | ||
375 | } | ||
376 | #define PKTFRMNATIVE(osh, skb) osl_pkt_frmnative(((osl_pubinfo_t *)osh), (struct sk_buff*)(skb)) | ||
377 | |||
378 | |||
379 | static INLINE struct sk_buff * | ||
380 | osl_pkt_tonative(osl_pubinfo_t *osh, void *pkt) | ||
381 | { | ||
382 | struct sk_buff *nskb; | ||
383 | |||
384 | if (osh->pkttag) | ||
385 | bzero(((struct sk_buff*)pkt)->cb, OSL_PKTTAG_SZ); | ||
386 | |||
387 | |||
388 | for (nskb = (struct sk_buff *)pkt; nskb; nskb = nskb->next) { | ||
389 | osh->pktalloced--; | ||
390 | } | ||
391 | |||
392 | return (struct sk_buff *)pkt; | ||
393 | } | ||
394 | #define PKTTONATIVE(osh, pkt) osl_pkt_tonative((osl_pubinfo_t *)(osh), (pkt)) | ||
395 | |||
396 | #define PKTLINK(skb) (((struct sk_buff*)(skb))->prev) | ||
397 | #define PKTSETLINK(skb, x) (((struct sk_buff*)(skb))->prev = (struct sk_buff*)(x)) | ||
398 | #define PKTPRIO(skb) (((struct sk_buff*)(skb))->priority) | ||
399 | #define PKTSETPRIO(skb, x) (((struct sk_buff*)(skb))->priority = (x)) | ||
400 | #define PKTSUMNEEDED(skb) (((struct sk_buff*)(skb))->ip_summed == CHECKSUM_HW) | ||
401 | #define PKTSETSUMGOOD(skb, x) (((struct sk_buff*)(skb))->ip_summed = \ | ||
402 | ((x) ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE)) | ||
403 | |||
404 | #define PKTSHARED(skb) (((struct sk_buff*)(skb))->cloned) | ||
405 | |||
406 | |||
407 | |||
408 | #else | ||
409 | |||
410 | |||
411 | |||
412 | #define ASSERT(exp) do {} while (0) | ||
413 | |||
414 | |||
415 | #define MALLOC(o, l) malloc(l) | ||
416 | #define MFREE(o, p, l) free(p) | ||
417 | #include <stdlib.h> | ||
418 | |||
419 | |||
420 | #include <string.h> | ||
421 | |||
422 | |||
423 | #include <stdio.h> | ||
424 | |||
425 | |||
426 | extern void bcopy(const void *src, void *dst, size_t len); | ||
427 | extern int bcmp(const void *b1, const void *b2, size_t len); | ||
428 | extern void bzero(void *b, size_t len); | ||
429 | #endif | ||
430 | |||
431 | #endif | ||