projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging: brcm80211: Remove dead code from linux_osl.c.
[deliverable/linux.git] / drivers / staging / brcm80211 / util / linux_osl.c
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
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 */
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 */
76 uint32 g_assert_type;
77
78 static s16 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:
167 case PCMCIA_BUS:
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
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)
216 if (pkttag) {
217 struct sk_buff *skb;
218 ASSERT(OSL_PKTTAG_SZ <= sizeof(skb->cb));
219 }
220 #endif
221 return osh;
222 }
223
224 void osl_detach(osl_t *osh)
225 {
226 if (osh == NULL)
227 return;
228
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
236 ASSERT(osh->magic == OS_HANDLE_MAGIC);
237 kfree(osh);
238 }
239
240 /* Return a new packet. zero out pkttag */
241 void *BCMFASTPATH osl_pktget(osl_t *osh, uint len)
242 {
243 struct sk_buff *skb;
244
245 skb = dev_alloc_skb(len);
246 if (skb) {
247 skb_put(skb, len);
248 skb->priority = 0;
249
250 osh->pub.pktalloced++;
251 }
252
253 return (void *)skb;
254 }
255
256 /* Free the driver packet. Free the tag if present */
257 void BCMFASTPATH osl_pktfree(osl_t *osh, void *p, bool send)
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
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 */
356 uint32 osl_pci_read_config(osl_t *osh, uint offset, uint size)
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
378 return val;
379 }
380
381 void osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val)
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
398 #if defined(BCMDBG) && !defined(BRCM_FULLMAC)
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 */
406 uint osl_pci_bus(osl_t *osh)
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 */
414 uint osl_pci_slot(osl_t *osh)
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 void *osl_malloc(osl_t *osh, uint size)
422 {
423 void *addr;
424
425 /* only ASSERT if osh is defined */
426 if (osh)
427 ASSERT(osh->magic == OS_HANDLE_MAGIC);
428
429 #ifdef DHD_USE_STATIC_BUF
430 if (bcm_static_buf) {
431 int i = 0;
432 if ((size >= PAGE_SIZE) && (size <= STATIC_BUF_SIZE)) {
433 down(&bcm_static_buf->static_sem);
434 for (i = 0; i < MAX_STATIC_BUF_NUM; i++) {
435 if (bcm_static_buf->buf_use[i] == 0)
436 break;
437 }
438 if (i == MAX_STATIC_BUF_NUM) {
439 up(&bcm_static_buf->static_sem);
440 printk(KERN_ERR "all static buff in use!\n");
441 goto original;
442 }
443 bcm_static_buf->buf_use[i] = 1;
444 up(&bcm_static_buf->static_sem);
445
446 bzero(bcm_static_buf->buf_ptr + STATIC_BUF_SIZE * i,
447 size);
448 if (osh)
449 osh->malloced += size;
450
451 return (void *)(bcm_static_buf->buf_ptr +
452 STATIC_BUF_SIZE * i);
453 }
454 }
455 original:
456 #endif /* DHD_USE_STATIC_BUF */
457
458 addr = kmalloc(size, GFP_ATOMIC);
459 if (addr == NULL) {
460 if (osh)
461 osh->failed++;
462 return NULL;
463 }
464 if (osh)
465 osh->malloced += size;
466
467 return addr;
468 }
469
470 void osl_mfree(osl_t *osh, void *addr, uint size)
471 {
472 #ifdef DHD_USE_STATIC_BUF
473 if (bcm_static_buf) {
474 if ((addr > (void *)bcm_static_buf) && ((unsigned char *)addr
475 <= ((unsigned char *)
476 bcm_static_buf +
477 STATIC_BUF_TOTAL_LEN))) {
478 int buf_idx = 0;
479 buf_idx =
480 ((unsigned char *)addr -
481 bcm_static_buf->buf_ptr) / STATIC_BUF_SIZE;
482 down(&bcm_static_buf->static_sem);
483 bcm_static_buf->buf_use[buf_idx] = 0;
484 up(&bcm_static_buf->static_sem);
485
486 if (osh) {
487 ASSERT(osh->magic == OS_HANDLE_MAGIC);
488 osh->malloced -= size;
489 }
490 return;
491 }
492 }
493 #endif /* DHD_USE_STATIC_BUF */
494 if (osh) {
495 ASSERT(osh->magic == OS_HANDLE_MAGIC);
496 osh->malloced -= size;
497 }
498 kfree(addr);
499 }
500
501 uint osl_malloced(osl_t *osh)
502 {
503 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
504 return osh->malloced;
505 }
506
507 uint osl_dma_consistent_align(void)
508 {
509 return PAGE_SIZE;
510 }
511
512 #ifdef BRCM_FULLMAC
513 void *osl_dma_alloc_consistent(osl_t *osh, uint size, unsigned long *pap)
514 {
515 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
516
517 return pci_alloc_consistent(osh->pdev, size, (dma_addr_t *) pap);
518 }
519 #else /* !BRCM_FULLMAC */
520 void *osl_dma_alloc_consistent(osl_t *osh, uint size, u16 align_bits,
521 uint *alloced, unsigned long *pap)
522 {
523 u16 align = (1 << align_bits);
524 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
525
526 if (!ISALIGNED(DMA_CONSISTENT_ALIGN, align))
527 size += align;
528 *alloced = size;
529
530 return pci_alloc_consistent(osh->pdev, size, (dma_addr_t *) pap);
531 }
532 #endif /* BRCM_FULLMAC */
533
534 void osl_dma_free_consistent(osl_t *osh, void *va, uint size, unsigned long pa)
535 {
536 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
537
538 pci_free_consistent(osh->pdev, size, va, (dma_addr_t) pa);
539 }
540
541 uint BCMFASTPATH osl_dma_map(osl_t *osh, void *va, uint size, int direction)
542 {
543 int dir;
544
545 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
546 dir = (direction == DMA_TX) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE;
547 return pci_map_single(osh->pdev, va, size, dir);
548 }
549
550 void BCMFASTPATH osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction)
551 {
552 int dir;
553
554 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
555 dir = (direction == DMA_TX) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE;
556 pci_unmap_single(osh->pdev, (uint32) pa, size, dir);
557 }
558
559 #if defined(BCMDBG_ASSERT)
560 void osl_assert(char *exp, char *file, int line)
561 {
562 char tempbuf[256];
563 char *basename;
564
565 basename = strrchr(file, '/');
566 /* skip the '/' */
567 if (basename)
568 basename++;
569
570 if (!basename)
571 basename = file;
572
573 #ifdef BCMDBG_ASSERT
574 snprintf(tempbuf, 256,
575 "assertion \"%s\" failed: file \"%s\", line %d\n", exp,
576 basename, line);
577
578 /* Print assert message and give it time to be written to /var/log/messages */
579 if (!in_interrupt()) {
580 const int delay = 3;
581 printk(KERN_ERR "%s", tempbuf);
582 printk(KERN_ERR "panic in %d seconds\n", delay);
583 set_current_state(TASK_INTERRUPTIBLE);
584 schedule_timeout(delay * HZ);
585 }
586
587 switch (g_assert_type) {
588 case 0:
589 panic(KERN_ERR "%s", tempbuf);
590 break;
591 case 1:
592 printk(KERN_ERR "%s", tempbuf);
593 BUG();
594 break;
595 case 2:
596 printk(KERN_ERR "%s", tempbuf);
597 break;
598 default:
599 break;
600 }
601 #endif /* BCMDBG_ASSERT */
602
603 }
604 #endif /* defined(BCMDBG_ASSERT) */
605
606 void osl_delay(uint usec)
607 {
608 uint d;
609
610 while (usec > 0) {
611 d = MIN(usec, 1000);
612 udelay(d);
613 usec -= d;
614 }
615 }
616
617 #if defined(BCMSDIO) && !defined(BRCM_FULLMAC)
618 u8 osl_readb(osl_t *osh, volatile u8 *r)
619 {
620 osl_rreg_fn_t rreg = ((osl_pubinfo_t *) osh)->rreg_fn;
621 void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx;
622
623 return (u8) ((rreg) (ctx, (void *)r, sizeof(u8)));
624 }
625
626 u16 osl_readw(osl_t *osh, volatile u16 *r)
627 {
628 osl_rreg_fn_t rreg = ((osl_pubinfo_t *) osh)->rreg_fn;
629 void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx;
630
631 return (u16) ((rreg) (ctx, (void *)r, sizeof(u16)));
632 }
633
634 uint32 osl_readl(osl_t *osh, volatile uint32 *r)
635 {
636 osl_rreg_fn_t rreg = ((osl_pubinfo_t *) osh)->rreg_fn;
637 void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx;
638
639 return (uint32) ((rreg) (ctx, (void *)r, sizeof(uint32)));
640 }
641
642 void osl_writeb(osl_t *osh, volatile u8 *r, u8 v)
643 {
644 osl_wreg_fn_t wreg = ((osl_pubinfo_t *) osh)->wreg_fn;
645 void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx;
646
647 ((wreg) (ctx, (void *)r, v, sizeof(u8)));
648 }
649
650 void osl_writew(osl_t *osh, volatile u16 *r, u16 v)
651 {
652 osl_wreg_fn_t wreg = ((osl_pubinfo_t *) osh)->wreg_fn;
653 void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx;
654
655 ((wreg) (ctx, (void *)r, v, sizeof(u16)));
656 }
657
658 void osl_writel(osl_t *osh, volatile uint32 *r, uint32 v)
659 {
660 osl_wreg_fn_t wreg = ((osl_pubinfo_t *) osh)->wreg_fn;
661 void *ctx = ((osl_pubinfo_t *) osh)->reg_ctx;
662
663 ((wreg) (ctx, (void *)r, v, sizeof(uint32)));
664 }
665 #endif /* BCMSDIO */
666 /* Linux Kernel: File Operations: end */
Linux kernel - Deliverables
This page took 0.057937 seconds and 5 git commands to generate.