Commit | Line | Data |
---|---|---|
a9533e7e HP |
1 | /* |
2 | * Copyright (c) 2010 Broadcom Corporation | |
3 | * | |
4 | * Permission to use, copy, modify, and/or distribute this software for any | |
5 | * purpose with or without fee is hereby granted, provided that the above | |
6 | * copyright notice and this permission notice appear in all copies. | |
7 | * | |
8 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
9 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
10 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY | |
11 | * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
12 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION | |
13 | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN | |
14 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
15 | */ | |
16 | ||
17 | #include <typedefs.h> | |
18 | #include <bcmendian.h> | |
19 | #include <linuxver.h> | |
20 | #include <bcmdefs.h> | |
21 | #include <osl.h> | |
22 | #include <bcmutils.h> | |
23 | #include <linux/delay.h> | |
24 | #ifdef mips | |
25 | #include <asm/paccess.h> | |
26 | #endif /* mips */ | |
27 | #include <pcicfg.h> | |
28 | ||
29 | #include <linux/fs.h> | |
30 | ||
31 | #define PCI_CFG_RETRY 10 | |
32 | ||
33 | #define OS_HANDLE_MAGIC 0x1234abcd /* Magic # to recognise osh */ | |
34 | #define BCM_MEM_FILENAME_LEN 24 /* Mem. filename length */ | |
35 | ||
194c6072 | 36 | #ifdef DHD_USE_STATIC_BUF |
37 | #define MAX_STATIC_BUF_NUM 16 | |
38 | #define STATIC_BUF_SIZE (PAGE_SIZE*2) | |
39 | #define STATIC_BUF_TOTAL_LEN (MAX_STATIC_BUF_NUM*STATIC_BUF_SIZE) | |
40 | typedef struct bcm_static_buf { | |
41 | struct semaphore static_sem; | |
42 | unsigned char *buf_ptr; | |
43 | unsigned char buf_use[MAX_STATIC_BUF_NUM]; | |
44 | } bcm_static_buf_t; | |
45 | ||
46 | static bcm_static_buf_t *bcm_static_buf = 0; | |
47 | ||
48 | #define MAX_STATIC_PKT_NUM 8 | |
49 | typedef struct bcm_static_pkt { | |
50 | struct sk_buff *skb_4k[MAX_STATIC_PKT_NUM]; | |
51 | struct sk_buff *skb_8k[MAX_STATIC_PKT_NUM]; | |
52 | struct semaphore osl_pkt_sem; | |
53 | unsigned char pkt_use[MAX_STATIC_PKT_NUM * 2]; | |
54 | } bcm_static_pkt_t; | |
55 | static bcm_static_pkt_t *bcm_static_skb = 0; | |
56 | #endif /* DHD_USE_STATIC_BUF */ | |
a9533e7e HP |
57 | typedef struct bcm_mem_link { |
58 | struct bcm_mem_link *prev; | |
59 | struct bcm_mem_link *next; | |
60 | uint size; | |
61 | int line; | |
62 | char file[BCM_MEM_FILENAME_LEN]; | |
63 | } bcm_mem_link_t; | |
64 | ||
65 | struct osl_info { | |
66 | osl_pubinfo_t pub; | |
67 | uint magic; | |
68 | void *pdev; | |
69 | uint malloced; | |
70 | uint failed; | |
71 | uint bustype; | |
72 | bcm_mem_link_t *dbgmem_list; | |
73 | }; | |
74 | ||
75 | /* Global ASSERT type flag */ | |
e4e4d21f | 76 | uint32 g_assert_type; |
a9533e7e HP |
77 | |
78 | static int16 linuxbcmerrormap[] = { 0, /* 0 */ | |
79 | -EINVAL, /* BCME_ERROR */ | |
80 | -EINVAL, /* BCME_BADARG */ | |
81 | -EINVAL, /* BCME_BADOPTION */ | |
82 | -EINVAL, /* BCME_NOTUP */ | |
83 | -EINVAL, /* BCME_NOTDOWN */ | |
84 | -EINVAL, /* BCME_NOTAP */ | |
85 | -EINVAL, /* BCME_NOTSTA */ | |
86 | -EINVAL, /* BCME_BADKEYIDX */ | |
87 | -EINVAL, /* BCME_RADIOOFF */ | |
88 | -EINVAL, /* BCME_NOTBANDLOCKED */ | |
89 | -EINVAL, /* BCME_NOCLK */ | |
90 | -EINVAL, /* BCME_BADRATESET */ | |
91 | -EINVAL, /* BCME_BADBAND */ | |
92 | -E2BIG, /* BCME_BUFTOOSHORT */ | |
93 | -E2BIG, /* BCME_BUFTOOLONG */ | |
94 | -EBUSY, /* BCME_BUSY */ | |
95 | -EINVAL, /* BCME_NOTASSOCIATED */ | |
96 | -EINVAL, /* BCME_BADSSIDLEN */ | |
97 | -EINVAL, /* BCME_OUTOFRANGECHAN */ | |
98 | -EINVAL, /* BCME_BADCHAN */ | |
99 | -EFAULT, /* BCME_BADADDR */ | |
100 | -ENOMEM, /* BCME_NORESOURCE */ | |
101 | -EOPNOTSUPP, /* BCME_UNSUPPORTED */ | |
102 | -EMSGSIZE, /* BCME_BADLENGTH */ | |
103 | -EINVAL, /* BCME_NOTREADY */ | |
104 | -EPERM, /* BCME_NOTPERMITTED */ | |
105 | -ENOMEM, /* BCME_NOMEM */ | |
106 | -EINVAL, /* BCME_ASSOCIATED */ | |
107 | -ERANGE, /* BCME_RANGE */ | |
108 | -EINVAL, /* BCME_NOTFOUND */ | |
109 | -EINVAL, /* BCME_WME_NOT_ENABLED */ | |
110 | -EINVAL, /* BCME_TSPEC_NOTFOUND */ | |
111 | -EINVAL, /* BCME_ACM_NOTSUPPORTED */ | |
112 | -EINVAL, /* BCME_NOT_WME_ASSOCIATION */ | |
113 | -EIO, /* BCME_SDIO_ERROR */ | |
114 | -ENODEV, /* BCME_DONGLE_DOWN */ | |
115 | -EINVAL, /* BCME_VERSION */ | |
116 | -EIO, /* BCME_TXFAIL */ | |
117 | -EIO, /* BCME_RXFAIL */ | |
118 | -EINVAL, /* BCME_NODEVICE */ | |
119 | -EINVAL, /* BCME_NMODE_DISABLED */ | |
120 | -ENODATA, /* BCME_NONRESIDENT */ | |
121 | ||
122 | /* When an new error code is added to bcmutils.h, add os | |
123 | * spcecific error translation here as well | |
124 | */ | |
125 | /* check if BCME_LAST changed since the last time this function was updated */ | |
126 | #if BCME_LAST != -42 | |
127 | #error "You need to add a OS error translation in the linuxbcmerrormap \ | |
128 | for new error code defined in bcmutils.h" | |
129 | #endif | |
130 | }; | |
131 | ||
132 | /* translate bcmerrors into linux errors */ | |
133 | int osl_error(int bcmerror) | |
134 | { | |
135 | if (bcmerror > 0) | |
136 | bcmerror = 0; | |
137 | else if (bcmerror < BCME_LAST) | |
138 | bcmerror = BCME_ERROR; | |
139 | ||
140 | /* Array bounds covered by ASSERT in osl_attach */ | |
141 | return linuxbcmerrormap[-bcmerror]; | |
142 | } | |
143 | ||
144 | osl_t *osl_attach(void *pdev, uint bustype, bool pkttag) | |
145 | { | |
146 | osl_t *osh; | |
147 | ||
148 | osh = kmalloc(sizeof(osl_t), GFP_ATOMIC); | |
149 | ASSERT(osh); | |
150 | ||
151 | bzero(osh, sizeof(osl_t)); | |
152 | ||
153 | /* Check that error map has the right number of entries in it */ | |
154 | ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(linuxbcmerrormap) - 1)); | |
155 | ||
156 | osh->magic = OS_HANDLE_MAGIC; | |
157 | osh->malloced = 0; | |
158 | osh->failed = 0; | |
159 | osh->dbgmem_list = NULL; | |
160 | osh->pdev = pdev; | |
161 | osh->pub.pkttag = pkttag; | |
162 | osh->bustype = bustype; | |
163 | ||
164 | switch (bustype) { | |
165 | case PCI_BUS: | |
166 | case SI_BUS: | |
194c6072 | 167 | case PCMCIA_BUS: |
a9533e7e HP |
168 | osh->pub.mmbus = TRUE; |
169 | break; | |
170 | case JTAG_BUS: | |
171 | case SDIO_BUS: | |
172 | case USB_BUS: | |
173 | case SPI_BUS: | |
174 | case RPC_BUS: | |
175 | osh->pub.mmbus = FALSE; | |
176 | break; | |
177 | default: | |
178 | ASSERT(FALSE); | |
179 | break; | |
180 | } | |
181 | ||
194c6072 | 182 | #ifdef DHD_USE_STATIC_BUF |
183 | ||
184 | if (!bcm_static_buf) { | |
185 | if (!(bcm_static_buf = | |
186 | (bcm_static_buf_t *) dhd_os_prealloc(3, | |
187 | STATIC_BUF_SIZE + STATIC_BUF_TOTAL_LEN))) { | |
188 | printk(KERN_ERR "can not alloc static buf!\n"); | |
189 | } else | |
190 | printk(KERN_ERR "alloc static buf at %x!\n", | |
191 | (unsigned int)bcm_static_buf); | |
192 | ||
193 | init_MUTEX(&bcm_static_buf->static_sem); | |
194 | ||
195 | bcm_static_buf->buf_ptr = | |
196 | (unsigned char *)bcm_static_buf + STATIC_BUF_SIZE; | |
197 | ||
198 | } | |
199 | ||
200 | if (!bcm_static_skb) { | |
201 | int i; | |
202 | void *skb_buff_ptr = 0; | |
203 | bcm_static_skb = | |
204 | (bcm_static_pkt_t *) ((char *)bcm_static_buf + 2048); | |
205 | skb_buff_ptr = dhd_os_prealloc(4, 0); | |
206 | ||
207 | bcopy(skb_buff_ptr, bcm_static_skb, | |
208 | sizeof(struct sk_buff *) * 16); | |
209 | for (i = 0; i < MAX_STATIC_PKT_NUM * 2; i++) | |
210 | bcm_static_skb->pkt_use[i] = 0; | |
211 | ||
212 | init_MUTEX(&bcm_static_skb->osl_pkt_sem); | |
213 | } | |
214 | #endif /* DHD_USE_STATIC_BUF */ | |
215 | #if defined(BCMDBG) && !defined(BRCM_FULLMAC) | |
a9533e7e HP |
216 | if (pkttag) { |
217 | struct sk_buff *skb; | |
218 | ASSERT(OSL_PKTTAG_SZ <= sizeof(skb->cb)); | |
219 | } | |
220 | #endif | |
221 | return osh; | |
222 | } | |
223 | ||
7cc4a4c0 | 224 | void osl_detach(osl_t *osh) |
a9533e7e HP |
225 | { |
226 | if (osh == NULL) | |
227 | return; | |
228 | ||
194c6072 | 229 | #ifdef DHD_USE_STATIC_BUF |
230 | if (bcm_static_buf) | |
231 | bcm_static_buf = 0; | |
232 | ||
233 | if (bcm_static_skb) | |
234 | bcm_static_skb = 0; | |
235 | #endif | |
a9533e7e HP |
236 | ASSERT(osh->magic == OS_HANDLE_MAGIC); |
237 | kfree(osh); | |
238 | } | |
239 | ||
240 | /* Return a new packet. zero out pkttag */ | |
7cc4a4c0 | 241 | void *BCMFASTPATH osl_pktget(osl_t *osh, uint len) |
a9533e7e HP |
242 | { |
243 | struct sk_buff *skb; | |
244 | ||
ca8c1e59 JC |
245 | skb = dev_alloc_skb(len); |
246 | if (skb) { | |
a9533e7e HP |
247 | skb_put(skb, len); |
248 | skb->priority = 0; | |
249 | ||
250 | osh->pub.pktalloced++; | |
251 | } | |
252 | ||
90ea2296 | 253 | return (void *)skb; |
a9533e7e HP |
254 | } |
255 | ||
256 | /* Free the driver packet. Free the tag if present */ | |
7cc4a4c0 | 257 | void BCMFASTPATH osl_pktfree(osl_t *osh, void *p, bool send) |
a9533e7e HP |
258 | { |
259 | struct sk_buff *skb, *nskb; | |
260 | int nest = 0; | |
261 | ||
262 | skb = (struct sk_buff *)p; | |
263 | ASSERT(skb); | |
264 | ||
265 | if (send && osh->pub.tx_fn) | |
266 | osh->pub.tx_fn(osh->pub.tx_ctx, p, 0); | |
267 | ||
268 | /* perversion: we use skb->next to chain multi-skb packets */ | |
269 | while (skb) { | |
270 | nskb = skb->next; | |
271 | skb->next = NULL; | |
272 | ||
273 | if (skb->destructor) | |
274 | /* cannot kfree_skb() on hard IRQ (net/core/skbuff.c) if | |
275 | * destructor exists | |
276 | */ | |
277 | dev_kfree_skb_any(skb); | |
278 | else | |
279 | /* can free immediately (even in_irq()) if destructor | |
280 | * does not exist | |
281 | */ | |
282 | dev_kfree_skb(skb); | |
283 | ||
284 | osh->pub.pktalloced--; | |
285 | nest++; | |
286 | skb = nskb; | |
287 | } | |
288 | } | |
289 | ||
194c6072 | 290 | #ifdef DHD_USE_STATIC_BUF |
291 | void *osl_pktget_static(osl_t *osh, uint len) | |
292 | { | |
293 | int i = 0; | |
294 | struct sk_buff *skb; | |
295 | ||
296 | if (len > (PAGE_SIZE * 2)) { | |
297 | printk(KERN_ERR "Do we really need this big skb??\n"); | |
298 | return osl_pktget(osh, len); | |
299 | } | |
300 | ||
301 | down(&bcm_static_skb->osl_pkt_sem); | |
302 | if (len <= PAGE_SIZE) { | |
303 | for (i = 0; i < MAX_STATIC_PKT_NUM; i++) { | |
304 | if (bcm_static_skb->pkt_use[i] == 0) | |
305 | break; | |
306 | } | |
307 | ||
308 | if (i != MAX_STATIC_PKT_NUM) { | |
309 | bcm_static_skb->pkt_use[i] = 1; | |
310 | up(&bcm_static_skb->osl_pkt_sem); | |
311 | ||
312 | skb = bcm_static_skb->skb_4k[i]; | |
313 | skb->tail = skb->data + len; | |
314 | skb->len = len; | |
315 | ||
316 | return skb; | |
317 | } | |
318 | } | |
319 | ||
320 | for (i = 0; i < MAX_STATIC_PKT_NUM; i++) { | |
321 | if (bcm_static_skb->pkt_use[i + MAX_STATIC_PKT_NUM] == 0) | |
322 | break; | |
323 | } | |
324 | ||
325 | if (i != MAX_STATIC_PKT_NUM) { | |
326 | bcm_static_skb->pkt_use[i + MAX_STATIC_PKT_NUM] = 1; | |
327 | up(&bcm_static_skb->osl_pkt_sem); | |
328 | skb = bcm_static_skb->skb_8k[i]; | |
329 | skb->tail = skb->data + len; | |
330 | skb->len = len; | |
331 | ||
332 | return skb; | |
333 | } | |
334 | ||
335 | up(&bcm_static_skb->osl_pkt_sem); | |
336 | printk(KERN_ERR "all static pkt in use!\n"); | |
337 | return osl_pktget(osh, len); | |
338 | } | |
339 | ||
340 | void osl_pktfree_static(osl_t *osh, void *p, bool send) | |
341 | { | |
342 | int i; | |
343 | ||
344 | for (i = 0; i < MAX_STATIC_PKT_NUM * 2; i++) { | |
345 | if (p == bcm_static_skb->skb_4k[i]) { | |
346 | down(&bcm_static_skb->osl_pkt_sem); | |
347 | bcm_static_skb->pkt_use[i] = 0; | |
348 | up(&bcm_static_skb->osl_pkt_sem); | |
349 | ||
350 | return; | |
351 | } | |
352 | } | |
353 | return osl_pktfree(osh, p, send); | |
354 | } | |
355 | #endif /* DHD_USE_STATIC_BUF */ | |
7cc4a4c0 | 356 | uint32 osl_pci_read_config(osl_t *osh, uint offset, uint size) |
a9533e7e HP |
357 | { |
358 | uint val = 0; | |
359 | uint retry = PCI_CFG_RETRY; | |
360 | ||
361 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
362 | ||
363 | /* only 4byte access supported */ | |
364 | ASSERT(size == 4); | |
365 | ||
366 | do { | |
367 | pci_read_config_dword(osh->pdev, offset, &val); | |
368 | if (val != 0xffffffff) | |
369 | break; | |
370 | } while (retry--); | |
371 | ||
372 | #ifdef BCMDBG | |
373 | if (retry < PCI_CFG_RETRY) | |
374 | printk("PCI CONFIG READ access to %d required %d retries\n", | |
375 | offset, (PCI_CFG_RETRY - retry)); | |
376 | #endif /* BCMDBG */ | |
377 | ||
90ea2296 | 378 | return val; |
a9533e7e HP |
379 | } |
380 | ||
7cc4a4c0 | 381 | void osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val) |
a9533e7e HP |
382 | { |
383 | uint retry = PCI_CFG_RETRY; | |
384 | ||
385 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
386 | ||
387 | /* only 4byte access supported */ | |
388 | ASSERT(size == 4); | |
389 | ||
390 | do { | |
391 | pci_write_config_dword(osh->pdev, offset, val); | |
392 | if (offset != PCI_BAR0_WIN) | |
393 | break; | |
394 | if (osl_pci_read_config(osh, offset, size) == val) | |
395 | break; | |
396 | } while (retry--); | |
397 | ||
194c6072 | 398 | #if defined(BCMDBG) && !defined(BRCM_FULLMAC) |
a9533e7e HP |
399 | if (retry < PCI_CFG_RETRY) |
400 | printk("PCI CONFIG WRITE access to %d required %d retries\n", | |
401 | offset, (PCI_CFG_RETRY - retry)); | |
402 | #endif /* BCMDBG */ | |
403 | } | |
404 | ||
405 | /* return bus # for the pci device pointed by osh->pdev */ | |
7cc4a4c0 | 406 | uint osl_pci_bus(osl_t *osh) |
a9533e7e HP |
407 | { |
408 | ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev); | |
409 | ||
410 | return ((struct pci_dev *)osh->pdev)->bus->number; | |
411 | } | |
412 | ||
413 | /* return slot # for the pci device pointed by osh->pdev */ | |
7cc4a4c0 | 414 | uint osl_pci_slot(osl_t *osh) |
a9533e7e HP |
415 | { |
416 | ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev); | |
417 | ||
418 | return PCI_SLOT(((struct pci_dev *)osh->pdev)->devfn); | |
419 | } | |
420 | ||
421 | static void | |
7cc4a4c0 | 422 | osl_pcmcia_attr(osl_t *osh, uint offset, char *buf, int size, bool write) |
a9533e7e HP |
423 | { |
424 | } | |
425 | ||
7cc4a4c0 | 426 | void osl_pcmcia_read_attr(osl_t *osh, uint offset, void *buf, int size) |
a9533e7e HP |
427 | { |
428 | osl_pcmcia_attr(osh, offset, (char *)buf, size, FALSE); | |
429 | } | |
430 | ||
7cc4a4c0 | 431 | void osl_pcmcia_write_attr(osl_t *osh, uint offset, void *buf, int size) |
a9533e7e HP |
432 | { |
433 | osl_pcmcia_attr(osh, offset, (char *)buf, size, TRUE); | |
434 | } | |
435 | ||
7cc4a4c0 | 436 | void *osl_malloc(osl_t *osh, uint size) |
a9533e7e HP |
437 | { |
438 | void *addr; | |
439 | ||
440 | /* only ASSERT if osh is defined */ | |
441 | if (osh) | |
442 | ASSERT(osh->magic == OS_HANDLE_MAGIC); | |
443 | ||
194c6072 | 444 | #ifdef DHD_USE_STATIC_BUF |
445 | if (bcm_static_buf) { | |
446 | int i = 0; | |
447 | if ((size >= PAGE_SIZE) && (size <= STATIC_BUF_SIZE)) { | |
448 | down(&bcm_static_buf->static_sem); | |
449 | for (i = 0; i < MAX_STATIC_BUF_NUM; i++) { | |
450 | if (bcm_static_buf->buf_use[i] == 0) | |
451 | break; | |
452 | } | |
453 | if (i == MAX_STATIC_BUF_NUM) { | |
454 | up(&bcm_static_buf->static_sem); | |
455 | printk(KERN_ERR "all static buff in use!\n"); | |
456 | goto original; | |
457 | } | |
458 | bcm_static_buf->buf_use[i] = 1; | |
459 | up(&bcm_static_buf->static_sem); | |
460 | ||
461 | bzero(bcm_static_buf->buf_ptr + STATIC_BUF_SIZE * i, | |
462 | size); | |
463 | if (osh) | |
464 | osh->malloced += size; | |
465 | ||
466 | return (void *)(bcm_static_buf->buf_ptr + | |
467 | STATIC_BUF_SIZE * i); | |
468 | } | |
469 | } | |
470 | original: | |
471 | #endif /* DHD_USE_STATIC_BUF */ | |
472 | ||
ca8c1e59 JC |
473 | addr = kmalloc(size, GFP_ATOMIC); |
474 | if (addr == NULL) { | |
a9533e7e HP |
475 | if (osh) |
476 | osh->failed++; | |
90ea2296 | 477 | return NULL; |
a9533e7e HP |
478 | } |
479 | if (osh) | |
480 | osh->malloced += size; | |
481 | ||
90ea2296 | 482 | return addr; |
a9533e7e HP |
483 | } |
484 | ||
7cc4a4c0 | 485 | void osl_mfree(osl_t *osh, void *addr, uint size) |
a9533e7e | 486 | { |
194c6072 | 487 | #ifdef DHD_USE_STATIC_BUF |
488 | if (bcm_static_buf) { | |
489 | if ((addr > (void *)bcm_static_buf) && ((unsigned char *)addr | |
490 | <= ((unsigned char *) | |
491 | bcm_static_buf + | |
492 | STATIC_BUF_TOTAL_LEN))) { | |
493 | int buf_idx = 0; | |
494 | buf_idx = | |
495 | ((unsigned char *)addr - | |
496 | bcm_static_buf->buf_ptr) / STATIC_BUF_SIZE; | |
497 | down(&bcm_static_buf->static_sem); | |
498 | bcm_static_buf->buf_use[buf_idx] = 0; | |
499 | up(&bcm_static_buf->static_sem); | |
500 | ||
501 | if (osh) { | |
502 | ASSERT(osh->magic == OS_HANDLE_MAGIC); | |
503 | osh->malloced -= size; | |
504 | } | |
505 | return; | |
506 | } | |
507 | } | |
508 | #endif /* DHD_USE_STATIC_BUF */ | |
a9533e7e HP |
509 | if (osh) { |
510 | ASSERT(osh->magic == OS_HANDLE_MAGIC); | |
511 | osh->malloced -= size; | |
512 | } | |
513 | kfree(addr); | |
514 | } | |
515 | ||
7cc4a4c0 | 516 | uint osl_malloced(osl_t *osh) |
a9533e7e HP |
517 | { |
518 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
90ea2296 | 519 | return osh->malloced; |
a9533e7e HP |
520 | } |
521 | ||
7cc4a4c0 | 522 | uint osl_malloc_failed(osl_t *osh) |
a9533e7e HP |
523 | { |
524 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
90ea2296 | 525 | return osh->failed; |
a9533e7e HP |
526 | } |
527 | ||
528 | uint osl_dma_consistent_align(void) | |
529 | { | |
90ea2296 | 530 | return PAGE_SIZE; |
a9533e7e HP |
531 | } |
532 | ||
194c6072 | 533 | #ifdef BRCM_FULLMAC |
534 | void *osl_dma_alloc_consistent(osl_t *osh, uint size, unsigned long *pap) | |
535 | { | |
536 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
537 | ||
538 | return pci_alloc_consistent(osh->pdev, size, (dma_addr_t *) pap); | |
539 | } | |
540 | #else /* !BRCM_FULLMAC */ | |
7cc4a4c0 | 541 | void *osl_dma_alloc_consistent(osl_t *osh, uint size, uint16 align_bits, |
3deea904 | 542 | uint *alloced, unsigned long *pap) |
a9533e7e HP |
543 | { |
544 | uint16 align = (1 << align_bits); | |
545 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
546 | ||
547 | if (!ISALIGNED(DMA_CONSISTENT_ALIGN, align)) | |
548 | size += align; | |
549 | *alloced = size; | |
550 | ||
90ea2296 | 551 | return pci_alloc_consistent(osh->pdev, size, (dma_addr_t *) pap); |
a9533e7e | 552 | } |
194c6072 | 553 | #endif /* BRCM_FULLMAC */ |
a9533e7e | 554 | |
3deea904 | 555 | void osl_dma_free_consistent(osl_t *osh, void *va, uint size, unsigned long pa) |
a9533e7e HP |
556 | { |
557 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
558 | ||
559 | pci_free_consistent(osh->pdev, size, va, (dma_addr_t) pa); | |
560 | } | |
561 | ||
7cc4a4c0 | 562 | uint BCMFASTPATH osl_dma_map(osl_t *osh, void *va, uint size, int direction) |
a9533e7e HP |
563 | { |
564 | int dir; | |
565 | ||
566 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
567 | dir = (direction == DMA_TX) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE; | |
90ea2296 | 568 | return pci_map_single(osh->pdev, va, size, dir); |
a9533e7e HP |
569 | } |
570 | ||
7cc4a4c0 | 571 | void BCMFASTPATH osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction) |
a9533e7e HP |
572 | { |
573 | int dir; | |
574 | ||
575 | ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC))); | |
576 | dir = (direction == DMA_TX) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE; | |
577 | pci_unmap_single(osh->pdev, (uint32) pa, size, dir); | |
578 | } | |
579 | ||
580 | #if defined(BCMDBG_ASSERT) | |
581 | void osl_assert(char *exp, char *file, int line) | |
582 | { | |
583 | char tempbuf[256]; | |
584 | char *basename; | |
585 | ||
586 | basename = strrchr(file, '/'); | |
587 | /* skip the '/' */ | |
588 | if (basename) | |
589 | basename++; | |
590 | ||
591 | if (!basename) | |
592 | basename = file; | |
593 | ||
594 | #ifdef BCMDBG_ASSERT | |
595 | snprintf(tempbuf, 256, | |
596 | "assertion \"%s\" failed: file \"%s\", line %d\n", exp, | |
597 | basename, line); | |
598 | ||
599 | /* Print assert message and give it time to be written to /var/log/messages */ | |
600 | if (!in_interrupt()) { | |
601 | const int delay = 3; | |
194c6072 | 602 | printk(KERN_ERR "%s", tempbuf); |
603 | printk(KERN_ERR "panic in %d seconds\n", delay); | |
a9533e7e HP |
604 | set_current_state(TASK_INTERRUPTIBLE); |
605 | schedule_timeout(delay * HZ); | |
606 | } | |
607 | ||
608 | switch (g_assert_type) { | |
609 | case 0: | |
194c6072 | 610 | panic(KERN_ERR "%s", tempbuf); |
a9533e7e HP |
611 | break; |
612 | case 1: | |
194c6072 | 613 | printk(KERN_ERR "%s", tempbuf); |
a9533e7e HP |
614 | BUG(); |
615 | break; | |
616 | case 2: | |
194c6072 | 617 | printk(KERN_ERR "%s", tempbuf); |
a9533e7e HP |
618 | break; |
619 | default: | |
620 | break; | |
621 | } | |
622 | #endif /* BCMDBG_ASSERT */ | |
623 | ||
624 | } | |
625 | #endif /* defined(BCMDBG_ASSERT) */ | |
626 | ||
627 | void osl_delay(uint usec) | |
628 | { | |
629 | uint d; | |
630 | ||
631 | while (usec > 0) { | |
632 | d = MIN(usec, 1000); | |
633 | udelay(d); | |
634 | usec -= d; | |
635 | } | |
636 | } | |
637 | ||
638 | /* Clone a packet. | |
639 | * The pkttag contents are NOT cloned. | |
640 | */ | |
7cc4a4c0 | 641 | void *osl_pktdup(osl_t *osh, void *skb) |
a9533e7e HP |
642 | { |
643 | void *p; | |
644 | ||
ca8c1e59 JC |
645 | p = skb_clone((struct sk_buff *)skb, GFP_ATOMIC); |
646 | if (p == NULL) | |
a9533e7e HP |
647 | return NULL; |
648 | ||
649 | /* skb_clone copies skb->cb.. we don't want that */ | |
650 | if (osh->pub.pkttag) | |
651 | bzero((void *)((struct sk_buff *)p)->cb, OSL_PKTTAG_SZ); | |
652 | ||
653 | /* Increment the packet counter */ | |
654 | osh->pub.pktalloced++; | |
90ea2296 | 655 | return p; |
a9533e7e HP |
656 | } |
657 | ||
194c6072 | 658 | #if defined(BCMSDIO) && !defined(BRCM_FULLMAC) |
36ef9a1e | 659 | u8 osl_readb(osl_t *osh, volatile u8 *r) |
a9533e7e HP |
660 | { |
661 | osl_rreg_fn_t rreg = ((osl_pubinfo_t *) osh)->rreg_fn; | |
662 | void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx; | |
663 | ||
36ef9a1e | 664 | return (u8) ((rreg) (ctx, (void *)r, sizeof(u8))); |
a9533e7e HP |
665 | } |
666 | ||
7cc4a4c0 | 667 | uint16 osl_readw(osl_t *osh, volatile uint16 *r) |
a9533e7e HP |
668 | { |
669 | osl_rreg_fn_t rreg = ((osl_pubinfo_t *) osh)->rreg_fn; | |
670 | void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx; | |
671 | ||
672 | return (uint16) ((rreg) (ctx, (void *)r, sizeof(uint16))); | |
673 | } | |
674 | ||
7cc4a4c0 | 675 | uint32 osl_readl(osl_t *osh, volatile uint32 *r) |
a9533e7e HP |
676 | { |
677 | osl_rreg_fn_t rreg = ((osl_pubinfo_t *) osh)->rreg_fn; | |
678 | void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx; | |
679 | ||
680 | return (uint32) ((rreg) (ctx, (void *)r, sizeof(uint32))); | |
681 | } | |
682 | ||
36ef9a1e | 683 | void osl_writeb(osl_t *osh, volatile u8 *r, u8 v) |
a9533e7e HP |
684 | { |
685 | osl_wreg_fn_t wreg = ((osl_pubinfo_t *) osh)->wreg_fn; | |
686 | void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx; | |
687 | ||
36ef9a1e | 688 | ((wreg) (ctx, (void *)r, v, sizeof(u8))); |
a9533e7e HP |
689 | } |
690 | ||
7cc4a4c0 | 691 | void osl_writew(osl_t *osh, volatile uint16 *r, uint16 v) |
a9533e7e HP |
692 | { |
693 | osl_wreg_fn_t wreg = ((osl_pubinfo_t *) osh)->wreg_fn; | |
694 | void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx; | |
695 | ||
696 | ((wreg) (ctx, (void *)r, v, sizeof(uint16))); | |
697 | } | |
698 | ||
7cc4a4c0 | 699 | void osl_writel(osl_t *osh, volatile uint32 *r, uint32 v) |
a9533e7e HP |
700 | { |
701 | osl_wreg_fn_t wreg = ((osl_pubinfo_t *) osh)->wreg_fn; | |
702 | void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx; | |
703 | ||
704 | ((wreg) (ctx, (void *)r, v, sizeof(uint32))); | |
705 | } | |
706 | #endif /* BCMSDIO */ | |
707 | /* Linux Kernel: File Operations: end */ |