M7350/kernel/drivers/net/wireless/bcmdhd/linux_osl.c
2024-09-09 08:52:07 +00:00

1054 lines
20 KiB
C

/*
* Linux OS Independent Layer
*
* Copyright (C) 1999-2012, Broadcom Corporation
*
* Unless you and Broadcom execute a separate written software license
* agreement governing use of this software, this software is licensed to you
* under the terms of the GNU General Public License version 2 (the "GPL"),
* available at http://www.broadcom.com/licenses/GPLv2.php, with the
* following added to such license:
*
* As a special exception, the copyright holders of this software give you
* permission to link this software with independent modules, and to copy and
* distribute the resulting executable under terms of your choice, provided that
* you also meet, for each linked independent module, the terms and conditions of
* the license of that module. An independent module is a module which is not
* derived from this software. The special exception does not apply to any
* modifications of the software.
*
* Notwithstanding the above, under no circumstances may you combine this
* software in any way with any other Broadcom software provided under a license
* other than the GPL, without Broadcom's express prior written consent.
*
* $Id: linux_osl.c 311099 2012-01-27 14:46:59Z $
*/
#define LINUX_PORT
#include <typedefs.h>
#include <bcmendian.h>
#include <linuxver.h>
#include <bcmdefs.h>
#include <osl.h>
#include <bcmutils.h>
#include <linux/delay.h>
#include <pcicfg.h>
#ifdef BCMASSERT_LOG
#include <bcm_assert_log.h>
#endif
#include <linux/fs.h>
#define PCI_CFG_RETRY 10
#define OS_HANDLE_MAGIC 0x1234abcd
#define BCM_MEM_FILENAME_LEN 24
#ifdef CONFIG_DHD_USE_STATIC_BUF
#define STATIC_BUF_MAX_NUM 16
#define STATIC_BUF_SIZE (PAGE_SIZE*2)
#define STATIC_BUF_TOTAL_LEN (STATIC_BUF_MAX_NUM * STATIC_BUF_SIZE)
typedef struct bcm_static_buf {
struct semaphore static_sem;
unsigned char *buf_ptr;
unsigned char buf_use[STATIC_BUF_MAX_NUM];
} bcm_static_buf_t;
static bcm_static_buf_t *bcm_static_buf = 0;
#define STATIC_PKT_MAX_NUM 8
typedef struct bcm_static_pkt {
struct sk_buff *skb_4k[STATIC_PKT_MAX_NUM];
struct sk_buff *skb_8k[STATIC_PKT_MAX_NUM];
struct semaphore osl_pkt_sem;
unsigned char pkt_use[STATIC_PKT_MAX_NUM * 2];
} bcm_static_pkt_t;
static bcm_static_pkt_t *bcm_static_skb = 0;
#endif
typedef struct bcm_mem_link {
struct bcm_mem_link *prev;
struct bcm_mem_link *next;
uint size;
int line;
void *osh;
char file[BCM_MEM_FILENAME_LEN];
} bcm_mem_link_t;
struct osl_info {
osl_pubinfo_t pub;
#ifdef CTFPOOL
ctfpool_t *ctfpool;
#endif
uint magic;
void *pdev;
atomic_t malloced;
uint failed;
uint bustype;
bcm_mem_link_t *dbgmem_list;
spinlock_t dbgmem_lock;
spinlock_t pktalloc_lock;
};
uint32 g_assert_type = FALSE;
static int16 linuxbcmerrormap[] =
{ 0,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-E2BIG,
-E2BIG,
-EBUSY,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EFAULT,
-ENOMEM,
-EOPNOTSUPP,
-EMSGSIZE,
-EINVAL,
-EPERM,
-ENOMEM,
-EINVAL,
-ERANGE,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EINVAL,
-EIO,
-ENODEV,
-EINVAL,
-EIO,
-EIO,
-ENODEV,
-EINVAL,
-ENODATA,
#if BCME_LAST != -42
#error "You need to add a OS error translation in the linuxbcmerrormap \
for new error code defined in bcmutils.h"
#endif
};
int
osl_error(int bcmerror)
{
if (bcmerror > 0)
bcmerror = 0;
else if (bcmerror < BCME_LAST)
bcmerror = BCME_ERROR;
return linuxbcmerrormap[-bcmerror];
}
extern uint8* dhd_os_prealloc(void *osh, int section, int size);
osl_t *
osl_attach(void *pdev, uint bustype, bool pkttag)
{
osl_t *osh;
osh = kmalloc(sizeof(osl_t), GFP_ATOMIC);
ASSERT(osh);
bzero(osh, sizeof(osl_t));
ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(linuxbcmerrormap) - 1));
osh->magic = OS_HANDLE_MAGIC;
atomic_set(&osh->malloced, 0);
osh->failed = 0;
osh->dbgmem_list = NULL;
spin_lock_init(&(osh->dbgmem_lock));
osh->pdev = pdev;
osh->pub.pkttag = pkttag;
osh->bustype = bustype;
switch (bustype) {
case PCI_BUS:
case SI_BUS:
case PCMCIA_BUS:
osh->pub.mmbus = TRUE;
break;
case JTAG_BUS:
case SDIO_BUS:
case USB_BUS:
case SPI_BUS:
case RPC_BUS:
osh->pub.mmbus = FALSE;
break;
default:
ASSERT(FALSE);
break;
}
#if defined(CONFIG_DHD_USE_STATIC_BUF)
if (!bcm_static_buf) {
if (!(bcm_static_buf = (bcm_static_buf_t *)dhd_os_prealloc(osh, 3, STATIC_BUF_SIZE+
STATIC_BUF_TOTAL_LEN))) {
printk("can not alloc static buf!\n");
}
else
printk("alloc static buf at %x!\n", (unsigned int)bcm_static_buf);
sema_init(&bcm_static_buf->static_sem, 1);
bcm_static_buf->buf_ptr = (unsigned char *)bcm_static_buf + STATIC_BUF_SIZE;
}
if (!bcm_static_skb) {
int i;
void *skb_buff_ptr = 0;
bcm_static_skb = (bcm_static_pkt_t *)((char *)bcm_static_buf + 2048);
skb_buff_ptr = dhd_os_prealloc(osh, 4, 0);
bcopy(skb_buff_ptr, bcm_static_skb, sizeof(struct sk_buff *)*16);
for (i = 0; i < STATIC_PKT_MAX_NUM * 2; i++)
bcm_static_skb->pkt_use[i] = 0;
sema_init(&bcm_static_skb->osl_pkt_sem, 1);
}
#endif
spin_lock_init(&(osh->pktalloc_lock));
return osh;
}
void
osl_detach(osl_t *osh)
{
if (osh == NULL)
return;
#ifdef CONFIG_DHD_USE_STATIC_BUF
if (bcm_static_buf) {
bcm_static_buf = 0;
}
if (bcm_static_skb) {
bcm_static_skb = 0;
}
#endif
ASSERT(osh->magic == OS_HANDLE_MAGIC);
kfree(osh);
}
static struct sk_buff *osl_alloc_skb(unsigned int len)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
gfp_t flags = GFP_ATOMIC;
return __dev_alloc_skb(len, flags);
#else
return dev_alloc_skb(len);
#endif
}
#ifdef CTFPOOL
#ifdef CTFPOOL_SPINLOCK
#define CTFPOOL_LOCK(ctfpool, flags) spin_lock_irqsave(&(ctfpool)->lock, flags)
#define CTFPOOL_UNLOCK(ctfpool, flags) spin_unlock_irqrestore(&(ctfpool)->lock, flags)
#else
#define CTFPOOL_LOCK(ctfpool, flags) spin_lock_bh(&(ctfpool)->lock)
#define CTFPOOL_UNLOCK(ctfpool, flags) spin_unlock_bh(&(ctfpool)->lock)
#endif
void *
osl_ctfpool_add(osl_t *osh)
{
struct sk_buff *skb;
#ifdef CTFPOOL_SPINLOCK
unsigned long flags;
#endif
if ((osh == NULL) || (osh->ctfpool == NULL))
return NULL;
CTFPOOL_LOCK(osh->ctfpool, flags);
ASSERT(osh->ctfpool->curr_obj <= osh->ctfpool->max_obj);
if (osh->ctfpool->curr_obj == osh->ctfpool->max_obj) {
CTFPOOL_UNLOCK(osh->ctfpool, flags);
return NULL;
}
skb = osl_alloc_skb(osh->ctfpool->obj_size);
if (skb == NULL) {
printf("%s: skb alloc of len %d failed\n", __FUNCTION__,
osh->ctfpool->obj_size);
CTFPOOL_UNLOCK(osh->ctfpool, flags);
return NULL;
}
skb->next = (struct sk_buff *)osh->ctfpool->head;
osh->ctfpool->head = skb;
osh->ctfpool->fast_frees++;
osh->ctfpool->curr_obj++;
CTFPOOLPTR(osh, skb) = (void *)osh->ctfpool;
PKTFAST(osh, skb) = FASTBUF;
CTFPOOL_UNLOCK(osh->ctfpool, flags);
return skb;
}
void
osl_ctfpool_replenish(osl_t *osh, uint thresh)
{
if ((osh == NULL) || (osh->ctfpool == NULL))
return;
while ((osh->ctfpool->refills > 0) && (thresh--)) {
osl_ctfpool_add(osh);
osh->ctfpool->refills--;
}
}
int32
osl_ctfpool_init(osl_t *osh, uint numobj, uint size)
{
osh->ctfpool = kmalloc(sizeof(ctfpool_t), GFP_ATOMIC);
ASSERT(osh->ctfpool);
bzero(osh->ctfpool, sizeof(ctfpool_t));
osh->ctfpool->max_obj = numobj;
osh->ctfpool->obj_size = size;
spin_lock_init(&osh->ctfpool->lock);
while (numobj--) {
if (!osl_ctfpool_add(osh))
return -1;
osh->ctfpool->fast_frees--;
}
return 0;
}
void
osl_ctfpool_cleanup(osl_t *osh)
{
struct sk_buff *skb, *nskb;
#ifdef CTFPOOL_SPINLOCK
unsigned long flags;
#endif
if ((osh == NULL) || (osh->ctfpool == NULL))
return;
CTFPOOL_LOCK(osh->ctfpool, flags);
skb = osh->ctfpool->head;
while (skb != NULL) {
nskb = skb->next;
dev_kfree_skb(skb);
skb = nskb;
osh->ctfpool->curr_obj--;
}
ASSERT(osh->ctfpool->curr_obj == 0);
osh->ctfpool->head = NULL;
CTFPOOL_UNLOCK(osh->ctfpool, flags);
kfree(osh->ctfpool);
osh->ctfpool = NULL;
}
void
osl_ctfpool_stats(osl_t *osh, void *b)
{
struct bcmstrbuf *bb;
if ((osh == NULL) || (osh->ctfpool == NULL))
return;
#ifdef CONFIG_DHD_USE_STATIC_BUF
if (bcm_static_buf) {
bcm_static_buf = 0;
}
if (bcm_static_skb) {
bcm_static_skb = 0;
}
#endif
bb = b;
ASSERT((osh != NULL) && (bb != NULL));
bcm_bprintf(bb, "max_obj %d obj_size %d curr_obj %d refills %d\n",
osh->ctfpool->max_obj, osh->ctfpool->obj_size,
osh->ctfpool->curr_obj, osh->ctfpool->refills);
bcm_bprintf(bb, "fast_allocs %d fast_frees %d slow_allocs %d\n",
osh->ctfpool->fast_allocs, osh->ctfpool->fast_frees,
osh->ctfpool->slow_allocs);
}
static inline struct sk_buff *
osl_pktfastget(osl_t *osh, uint len)
{
struct sk_buff *skb;
#ifdef CTFPOOL_SPINLOCK
unsigned long flags;
#endif
if (osh->ctfpool == NULL)
return NULL;
CTFPOOL_LOCK(osh->ctfpool, flags);
if (osh->ctfpool->head == NULL) {
ASSERT(osh->ctfpool->curr_obj == 0);
osh->ctfpool->slow_allocs++;
CTFPOOL_UNLOCK(osh->ctfpool, flags);
return NULL;
}
ASSERT(len <= osh->ctfpool->obj_size);
skb = (struct sk_buff *)osh->ctfpool->head;
osh->ctfpool->head = (void *)skb->next;
osh->ctfpool->fast_allocs++;
osh->ctfpool->curr_obj--;
ASSERT(CTFPOOLHEAD(osh, skb) == (struct sock *)osh->ctfpool->head);
CTFPOOL_UNLOCK(osh->ctfpool, flags);
skb->next = skb->prev = NULL;
skb->data = skb->head + 16;
skb->tail = skb->head + 16;
skb->len = 0;
skb->cloned = 0;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
skb->list = NULL;
#endif
atomic_set(&skb->users, 1);
return skb;
}
#endif
struct sk_buff * BCMFASTPATH
osl_pkt_tonative(osl_t *osh, void *pkt)
{
#ifndef WL_UMK
struct sk_buff *nskb;
unsigned long flags;
#endif
if (osh->pub.pkttag)
bzero((void*)((struct sk_buff *)pkt)->cb, OSL_PKTTAG_SZ);
#ifndef WL_UMK
for (nskb = (struct sk_buff *)pkt; nskb; nskb = nskb->next) {
spin_lock_irqsave(&osh->pktalloc_lock, flags);
osh->pub.pktalloced--;
spin_unlock_irqrestore(&osh->pktalloc_lock, flags);
}
#endif
return (struct sk_buff *)pkt;
}
void * BCMFASTPATH
osl_pkt_frmnative(osl_t *osh, void *pkt)
{
#ifndef WL_UMK
struct sk_buff *nskb;
unsigned long flags;
#endif
if (osh->pub.pkttag)
bzero((void*)((struct sk_buff *)pkt)->cb, OSL_PKTTAG_SZ);
#ifndef WL_UMK
for (nskb = (struct sk_buff *)pkt; nskb; nskb = nskb->next) {
spin_lock_irqsave(&osh->pktalloc_lock, flags);
osh->pub.pktalloced++;
spin_unlock_irqrestore(&osh->pktalloc_lock, flags);
}
#endif
return (void *)pkt;
}
void * BCMFASTPATH
osl_pktget(osl_t *osh, uint len)
{
struct sk_buff *skb;
unsigned long flags;
#ifdef CTFPOOL
skb = osl_pktfastget(osh, len);
if ((skb != NULL) || ((skb = osl_alloc_skb(len)) != NULL)) {
#else
if ((skb = osl_alloc_skb(len))) {
#endif
skb_put(skb, len);
skb->priority = 0;
spin_lock_irqsave(&osh->pktalloc_lock, flags);
osh->pub.pktalloced++;
spin_unlock_irqrestore(&osh->pktalloc_lock, flags);
}
return ((void*) skb);
}
#ifdef CTFPOOL
static inline void
osl_pktfastfree(osl_t *osh, struct sk_buff *skb)
{
ctfpool_t *ctfpool;
#ifdef CTFPOOL_SPINLOCK
unsigned long flags;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
skb->tstamp.tv.sec = 0;
#else
skb->stamp.tv_sec = 0;
#endif
skb->dev = NULL;
skb->dst = NULL;
memset(skb->cb, 0, sizeof(skb->cb));
skb->ip_summed = 0;
skb->destructor = NULL;
ctfpool = (ctfpool_t *)CTFPOOLPTR(osh, skb);
ASSERT(ctfpool != NULL);
CTFPOOL_LOCK(ctfpool, flags);
skb->next = (struct sk_buff *)ctfpool->head;
ctfpool->head = (void *)skb;
ctfpool->fast_frees++;
ctfpool->curr_obj++;
ASSERT(ctfpool->curr_obj <= ctfpool->max_obj);
CTFPOOL_UNLOCK(ctfpool, flags);
}
#endif
void BCMFASTPATH
osl_pktfree(osl_t *osh, void *p, bool send)
{
struct sk_buff *skb, *nskb;
unsigned long flags;
skb = (struct sk_buff*) p;
if (send && osh->pub.tx_fn)
osh->pub.tx_fn(osh->pub.tx_ctx, p, 0);
PKTDBG_TRACE(osh, (void *) skb, PKTLIST_PKTFREE);
while (skb) {
nskb = skb->next;
skb->next = NULL;
#ifdef CTFPOOL
if ((PKTISFAST(osh, skb)) && (atomic_read(&skb->users) == 1))
osl_pktfastfree(osh, skb);
else {
#else
{
#endif
if (skb->destructor)
dev_kfree_skb_any(skb);
else
dev_kfree_skb(skb);
}
spin_lock_irqsave(&osh->pktalloc_lock, flags);
osh->pub.pktalloced--;
spin_unlock_irqrestore(&osh->pktalloc_lock, flags);
skb = nskb;
}
}
#ifdef CONFIG_DHD_USE_STATIC_BUF
void*
osl_pktget_static(osl_t *osh, uint len)
{
int i = 0;
struct sk_buff *skb;
if (len > (PAGE_SIZE*2)) {
printk("%s: attempt to allocate huge packet (0x%x)\n", __FUNCTION__, len);
return osl_pktget(osh, len);
}
down(&bcm_static_skb->osl_pkt_sem);
if (len <= PAGE_SIZE) {
for (i = 0; i < STATIC_PKT_MAX_NUM; i++) {
if (bcm_static_skb->pkt_use[i] == 0)
break;
}
if (i != STATIC_PKT_MAX_NUM) {
bcm_static_skb->pkt_use[i] = 1;
up(&bcm_static_skb->osl_pkt_sem);
skb = bcm_static_skb->skb_4k[i];
skb->tail = skb->data + len;
skb->len = len;
return skb;
}
}
for (i = 0; i < STATIC_PKT_MAX_NUM; i++) {
if (bcm_static_skb->pkt_use[i+STATIC_PKT_MAX_NUM] == 0)
break;
}
if (i != STATIC_PKT_MAX_NUM) {
bcm_static_skb->pkt_use[i+STATIC_PKT_MAX_NUM] = 1;
up(&bcm_static_skb->osl_pkt_sem);
skb = bcm_static_skb->skb_8k[i];
skb->tail = skb->data + len;
skb->len = len;
return skb;
}
up(&bcm_static_skb->osl_pkt_sem);
printk("%s: all static pkt in use!\n", __FUNCTION__);
return osl_pktget(osh, len);
}
void
osl_pktfree_static(osl_t *osh, void *p, bool send)
{
int i;
for (i = 0; i < STATIC_PKT_MAX_NUM; i++) {
if (p == bcm_static_skb->skb_4k[i]) {
down(&bcm_static_skb->osl_pkt_sem);
bcm_static_skb->pkt_use[i] = 0;
up(&bcm_static_skb->osl_pkt_sem);
return;
}
}
for (i = 0; i < STATIC_PKT_MAX_NUM; i++) {
if (p == bcm_static_skb->skb_8k[i]) {
down(&bcm_static_skb->osl_pkt_sem);
bcm_static_skb->pkt_use[i + STATIC_PKT_MAX_NUM] = 0;
up(&bcm_static_skb->osl_pkt_sem);
return;
}
}
return osl_pktfree(osh, p, send);
}
#endif
uint32
osl_pci_read_config(osl_t *osh, uint offset, uint size)
{
uint val = 0;
uint retry = PCI_CFG_RETRY;
ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
ASSERT(size == 4);
do {
pci_read_config_dword(osh->pdev, offset, &val);
if (val != 0xffffffff)
break;
} while (retry--);
return (val);
}
void
osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val)
{
uint retry = PCI_CFG_RETRY;
ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
ASSERT(size == 4);
do {
pci_write_config_dword(osh->pdev, offset, val);
if (offset != PCI_BAR0_WIN)
break;
if (osl_pci_read_config(osh, offset, size) == val)
break;
} while (retry--);
}
uint
osl_pci_bus(osl_t *osh)
{
ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
return ((struct pci_dev *)osh->pdev)->bus->number;
}
uint
osl_pci_slot(osl_t *osh)
{
ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
return PCI_SLOT(((struct pci_dev *)osh->pdev)->devfn);
}
struct pci_dev *
osl_pci_device(osl_t *osh)
{
ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
return osh->pdev;
}
static void
osl_pcmcia_attr(osl_t *osh, uint offset, char *buf, int size, bool write)
{
}
void
osl_pcmcia_read_attr(osl_t *osh, uint offset, void *buf, int size)
{
osl_pcmcia_attr(osh, offset, (char *) buf, size, FALSE);
}
void
osl_pcmcia_write_attr(osl_t *osh, uint offset, void *buf, int size)
{
osl_pcmcia_attr(osh, offset, (char *) buf, size, TRUE);
}
void *
osl_malloc(osl_t *osh, uint size)
{
void *addr;
if (osh)
ASSERT(osh->magic == OS_HANDLE_MAGIC);
#ifdef CONFIG_DHD_USE_STATIC_BUF
if (bcm_static_buf)
{
int i = 0;
if ((size >= PAGE_SIZE)&&(size <= STATIC_BUF_SIZE))
{
down(&bcm_static_buf->static_sem);
for (i = 0; i < STATIC_BUF_MAX_NUM; i++)
{
if (bcm_static_buf->buf_use[i] == 0)
break;
}
if (i == STATIC_BUF_MAX_NUM)
{
up(&bcm_static_buf->static_sem);
printk("all static buff in use!\n");
goto original;
}
bcm_static_buf->buf_use[i] = 1;
up(&bcm_static_buf->static_sem);
bzero(bcm_static_buf->buf_ptr+STATIC_BUF_SIZE*i, size);
if (osh)
atomic_add(size, &osh->malloced);
return ((void *)(bcm_static_buf->buf_ptr+STATIC_BUF_SIZE*i));
}
}
original:
#endif
if ((addr = kmalloc(size, GFP_ATOMIC)) == NULL) {
if (osh)
osh->failed++;
return (NULL);
}
if (osh)
atomic_add(size, &osh->malloced);
return (addr);
}
void
osl_mfree(osl_t *osh, void *addr, uint size)
{
#ifdef CONFIG_DHD_USE_STATIC_BUF
if (bcm_static_buf)
{
if ((addr > (void *)bcm_static_buf) && ((unsigned char *)addr
<= ((unsigned char *)bcm_static_buf + STATIC_BUF_TOTAL_LEN)))
{
int buf_idx = 0;
buf_idx = ((unsigned char *)addr - bcm_static_buf->buf_ptr)/STATIC_BUF_SIZE;
down(&bcm_static_buf->static_sem);
bcm_static_buf->buf_use[buf_idx] = 0;
up(&bcm_static_buf->static_sem);
if (osh) {
ASSERT(osh->magic == OS_HANDLE_MAGIC);
atomic_sub(size, &osh->malloced);
}
return;
}
}
#endif
if (osh) {
ASSERT(osh->magic == OS_HANDLE_MAGIC);
atomic_sub(size, &osh->malloced);
}
kfree(addr);
}
uint
osl_malloced(osl_t *osh)
{
ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
return (atomic_read(&osh->malloced));
}
uint
osl_malloc_failed(osl_t *osh)
{
ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
return (osh->failed);
}
uint
osl_dma_consistent_align(void)
{
return (PAGE_SIZE);
}
void*
osl_dma_alloc_consistent(osl_t *osh, uint size, uint16 align_bits, uint *alloced, ulong *pap)
{
uint16 align = (1 << align_bits);
ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
if (!ISALIGNED(DMA_CONSISTENT_ALIGN, align))
size += align;
*alloced = size;
return (pci_alloc_consistent(osh->pdev, size, (dma_addr_t*)pap));
}
void
osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa)
{
ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
pci_free_consistent(osh->pdev, size, va, (dma_addr_t)pa);
}
uint BCMFASTPATH
osl_dma_map(osl_t *osh, void *va, uint size, int direction)
{
int dir;
ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
return (pci_map_single(osh->pdev, va, size, dir));
}
void BCMFASTPATH
osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction)
{
int dir;
ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
pci_unmap_single(osh->pdev, (uint32)pa, size, dir);
}
#if defined(BCMASSERT_LOG)
void
osl_assert(const char *exp, const char *file, int line)
{
char tempbuf[256];
const char *basename;
basename = strrchr(file, '/');
if (basename)
basename++;
if (!basename)
basename = file;
#ifdef BCMASSERT_LOG
snprintf(tempbuf, 64, "\"%s\": file \"%s\", line %d\n",
exp, basename, line);
bcm_assert_log(tempbuf);
#endif
}
#endif
void
osl_delay(uint usec)
{
uint d;
while (usec > 0) {
d = MIN(usec, 1000);
udelay(d);
usec -= d;
}
}
void *
osl_pktdup(osl_t *osh, void *skb)
{
void * p;
unsigned long irqflags;
PKTCTFMAP(osh, skb);
if ((p = skb_clone((struct sk_buff *)skb, GFP_ATOMIC)) == NULL)
return NULL;
#ifdef CTFPOOL
if (PKTISFAST(osh, skb)) {
ctfpool_t *ctfpool;
ctfpool = (ctfpool_t *)CTFPOOLPTR(osh, skb);
ASSERT(ctfpool != NULL);
PKTCLRFAST(osh, p);
PKTCLRFAST(osh, skb);
ctfpool->refills++;
}
#endif
if (osh->pub.pkttag)
bzero((void*)((struct sk_buff *)p)->cb, OSL_PKTTAG_SZ);
spin_lock_irqsave(&osh->pktalloc_lock, irqflags);
osh->pub.pktalloced++;
spin_unlock_irqrestore(&osh->pktalloc_lock, irqflags);
return (p);
}
void *
osl_os_open_image(char *filename)
{
struct file *fp;
fp = filp_open(filename, O_RDONLY, 0);
if (IS_ERR(fp))
fp = NULL;
return fp;
}
int
osl_os_get_image_block(char *buf, int len, void *image)
{
struct file *fp = (struct file *)image;
int rdlen;
if (!image)
return 0;
rdlen = kernel_read(fp, fp->f_pos, buf, len);
if (rdlen > 0)
fp->f_pos += rdlen;
return rdlen;
}
void
osl_os_close_image(void *image)
{
if (image)
filp_close((struct file *)image, NULL);
}