struct sk_buff *
__adf_nbuf_alloc_ncnb(adf_os_device_t osdev, size_t size, int reserve, int align, int prio)
{
struct sk_buff *skb;
unsigned long offset;
if(align)
size += (align - 1);
#ifdef CONFIG_COMCERTO_ZONE_DMA_NCNB
skb = __dev_alloc_skb(size, GFP_DMA_NCNB | GFP_ATOMIC);
#else
skb = __dev_alloc_skb(size, GFP_ATOMIC);
#endif
if (!skb) {
printk("ERROR:NBUF alloc failed\n");
return NULL;
}
memset(skb->cb, 0x0, sizeof(skb->cb));
/*
* The default is for netbuf fragments to be interpreted
* as wordstreams rather than bytestreams.
* Set the CVG_NBUF_MAX_EXTRA_FRAGS+1 wordstream_flags bits,
* to provide this default.
*/
NBUF_EXTRA_FRAG_WORDSTREAM_FLAGS(skb) =
(1 << (CVG_NBUF_MAX_EXTRA_FRAGS + 1)) - 1;
/**
* XXX:how about we reserve first then align
*/
/**
* Align & make sure that the tail & data are adjusted properly
*/
if(align) {
offset = ((unsigned long) skb->data) % align;
if(offset)
skb_reserve(skb, align - offset);
}
/**
* NOTE:alloc doesn't take responsibility if reserve unaligns the data
* pointer
*/
skb_reserve(skb, reserve);
return skb;
}
static inline struct sk_buff *__alloc_skb_from_kernel(int size, gfp_t gfp_mask)
{
struct sk_buff *skb = NULL;
if (size > SKB_1_5K)
skb = __dev_alloc_skb(SKB_4K, gfp_mask);
else if (size > SKB_16)
skb = __dev_alloc_skb(SKB_1_5K, gfp_mask);
else if (size > 0)
skb = __dev_alloc_skb(SKB_16, gfp_mask);
if (!skb)
CCCI_ERR_MSG(-1, BM, "%ps alloc skb from kernel fail, size=%d\n", __builtin_return_address(0), size);
return skb;
}
static int
fe_dma_ring_alloc(END_DEVICE *ei_local)
{
u32 i;
/* allocate QDMA HW TX pool */
ei_local->fq_head_page = dma_alloc_coherent(NULL, NUM_QDMA_PAGE * QDMA_PAGE_SIZE, &ei_local->fq_head_page_phy, GFP_KERNEL);
if (!ei_local->fq_head_page)
goto err_cleanup;
/* allocate QDMA HW TX descriptors */
ei_local->fq_head = dma_alloc_coherent(NULL, NUM_QDMA_PAGE * sizeof(struct QDMA_txdesc), &ei_local->fq_head_phy, GFP_KERNEL);
if (!ei_local->fq_head)
goto err_cleanup;
/* allocate QDMA SW TX descriptors */
ei_local->txd_pool = dma_alloc_coherent(NULL, NUM_TX_DESC * sizeof(struct QDMA_txdesc), &ei_local->txd_pool_phy, GFP_KERNEL);
if (!ei_local->txd_pool)
goto err_cleanup;
/* allocate PDMA (or QDMA) RX descriptors */
ei_local->rxd_ring = dma_alloc_coherent(NULL, NUM_RX_DESC * sizeof(struct PDMA_rxdesc), &ei_local->rxd_ring_phy, GFP_KERNEL);
if (!ei_local->rxd_ring)
goto err_cleanup;
#if !defined (CONFIG_RAETH_QDMATX_QDMARX)
/* allocate QDMA RX stub descriptors */
ei_local->qrx_ring = dma_alloc_coherent(NULL, NUM_QRX_DESC * sizeof(struct PDMA_rxdesc), &ei_local->qrx_ring_phy, GFP_KERNEL);
if (!ei_local->qrx_ring)
goto err_cleanup;
/* allocate QDMA RX stub buffer */
ei_local->qrx_buff = __dev_alloc_skb(MAX_RX_LENGTH + NET_IP_ALIGN, GFP_KERNEL);
if (!ei_local->qrx_buff)
goto err_cleanup;
#endif
/* allocate PDMA (or QDMA) RX buffers */
for (i = 0; i < NUM_RX_DESC; i++) {
ei_local->rxd_buff[i] = __dev_alloc_skb(MAX_RX_LENGTH + NET_IP_ALIGN, GFP_KERNEL);
if (!ei_local->rxd_buff[i])
goto err_cleanup;
}
return 0;
err_cleanup:
fe_dma_ring_free(ei_local);
return -ENOMEM;
}
PNDIS_PACKET DuplicatePacket(
IN PRTMP_ADAPTER pAd,
IN PNDIS_PACKET pPacket,
IN UCHAR FromWhichBSSID)
{
struct sk_buff *skb;
PNDIS_PACKET pRetPacket = NULL;
USHORT DataSize;
UCHAR *pData;
DataSize = (USHORT) GET_OS_PKT_LEN(pPacket);
pData = (PUCHAR) GET_OS_PKT_DATAPTR(pPacket);
skb = skb_clone(RTPKT_TO_OSPKT(pPacket), MEM_ALLOC_FLAG);
if (skb)
{
skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
pRetPacket = OSPKT_TO_RTPKT(skb);
}
#if 0
if ((skb = __dev_alloc_skb(DataSize + 2+32, MEM_ALLOC_FLAG)) != NULL)
{
skb_reserve(skb, 2+32);
NdisMoveMemory(skb->tail, pData, DataSize);
skb_put(skb, DataSize);
skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
pRetPacket = OSPKT_TO_RTPKT(skb);
}
#endif
return pRetPacket;
}
static struct sk_buff *_rtl_prep_rx_urb(struct ieee80211_hw *hw,
struct rtl_usb *rtlusb,
struct urb *urb,
gfp_t gfp_mask)
{
struct sk_buff *skb;
struct rtl_priv *rtlpriv = rtl_priv(hw);
skb = __dev_alloc_skb((rtlusb->rx_max_size + __RADIO_TAP_SIZE_RSV),
gfp_mask);
if (!skb) {
RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
"Failed to __dev_alloc_skb!!\n");
return ERR_PTR(-ENOMEM);
}
/* reserve some space for mac80211's radiotap */
skb_reserve(skb, __RADIO_TAP_SIZE_RSV);
usb_fill_bulk_urb(urb, rtlusb->udev,
usb_rcvbulkpipe(rtlusb->udev, rtlusb->in_ep),
skb->data, min(skb_tailroom(skb),
(int)rtlusb->rx_max_size),
_rtl_rx_completed, skb);
_rtl_install_trx_info(rtlusb, skb, rtlusb->in_ep);
return skb;
}
int ctcm_ch_alloc_buffer(struct channel *ch)
{
clear_normalized_cda(&ch->ccw[1]);
ch->trans_skb = __dev_alloc_skb(ch->max_bufsize, GFP_ATOMIC | GFP_DMA);
if (ch->trans_skb == NULL) {
CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
"%s(%s): %s trans_skb allocation error",
CTCM_FUNTAIL, ch->id,
(CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
return -ENOMEM;
}
ch->ccw[1].count = ch->max_bufsize;
if (set_normalized_cda(&ch->ccw[1], ch->trans_skb->data)) {
dev_kfree_skb(ch->trans_skb);
ch->trans_skb = NULL;
CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
"%s(%s): %s set norm_cda failed",
CTCM_FUNTAIL, ch->id,
(CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
return -ENOMEM;
}
ch->ccw[1].count = 0;
ch->trans_skb_data = ch->trans_skb->data;
ch->flags &= ~CHANNEL_FLAGS_BUFSIZE_CHANGED;
return 0;
}
struct sk_buff *ath_rxbuf_alloc(struct ath_common *common,
u32 len,
gfp_t gfp_mask)
{
struct sk_buff *skb;
u32 off;
/*
* Cache-line-align. This is important (for the
* 5210 at least) as not doing so causes bogus data
* in rx'd frames.
*/
/* Note: the kernel can allocate a value greater than
* what we ask it to give us. We really only need 4 KB as that
* is this hardware supports and in fact we need at least 3849
* as that is the MAX AMSDU size this hardware supports.
* Unfortunately this means we may get 8 KB here from the
* kernel... and that is actually what is observed on some
* systems :( */
skb = __dev_alloc_skb(len + common->cachelsz - 1, gfp_mask);
if (skb != NULL) {
off = ((unsigned long) skb->data) % common->cachelsz;
if (off != 0)
skb_reserve(skb, common->cachelsz - off);
} else {
pr_err("skbuff alloc of size %u failed\n", len);
return NULL;
}
return skb;
}
static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
int headroom, gfp_t gfp_mask)
{
struct ieee80211_txb *txb;
int i;
txb = kmalloc(sizeof(struct ieee80211_txb) + (sizeof(u8 *) * nr_frags),
gfp_mask);
if (!txb)
return NULL;
memset(txb, 0, sizeof(struct ieee80211_txb));
txb->nr_frags = nr_frags;
txb->frag_size = txb_size;
for (i = 0; i < nr_frags; i++) {
txb->fragments[i] = __dev_alloc_skb(txb_size + headroom,
gfp_mask);
if (unlikely(!txb->fragments[i])) {
i--;
break;
}
skb_reserve(txb->fragments[i], headroom);
}
if (unlikely(i != nr_frags)) {
while (i >= 0)
dev_kfree_skb_any(txb->fragments[i--]);
kfree(txb);
return NULL;
}
return txb;
}
static int p54u_init_urbs(struct ieee80211_hw *dev)
{
struct p54u_priv *priv = dev->priv;
struct urb *entry;
struct sk_buff *skb;
struct p54u_rx_info *info;
while (skb_queue_len(&priv->rx_queue) < 32) {
skb = __dev_alloc_skb(MAX_RX_SIZE, GFP_KERNEL);
if (!skb)
break;
entry = usb_alloc_urb(0, GFP_KERNEL);
if (!entry) {
kfree_skb(skb);
break;
}
usb_fill_bulk_urb(entry, priv->udev, usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), skb_tail_pointer(skb), MAX_RX_SIZE, p54u_rx_cb, skb);
info = (struct p54u_rx_info *) skb->cb;
info->urb = entry;
info->dev = dev;
skb_queue_tail(&priv->rx_queue, skb);
usb_submit_urb(entry, GFP_KERNEL);
}
return 0;
}
PNDIS_PACKET duplicate_pkt(
IN PRTMP_ADAPTER pAd,
IN PUCHAR pHeader802_3,
IN UINT HdrLen,
IN PUCHAR pData,
IN ULONG DataSize,
IN UCHAR FromWhichBSSID)
{
struct sk_buff *skb;
PNDIS_PACKET pPacket = NULL;
if ((skb = __dev_alloc_skb(HdrLen + DataSize + 2, MEM_ALLOC_FLAG)) != NULL)
{
skb_reserve(skb, 2);
NdisMoveMemory(skb_tail_pointer(skb), pHeader802_3, HdrLen);
skb_put(skb, HdrLen);
NdisMoveMemory(skb_tail_pointer(skb), pData, DataSize);
skb_put(skb, DataSize);
skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
pPacket = OSPKT_TO_RTPKT(skb);
}
return pPacket;
}
int get_rx_buffers(void *priv, void **pkt_priv, void **buffer, int size)
{
struct net_device *dev = (struct net_device *) priv;
struct sk_buff *skb = NULL;
void *ptr = NULL;
DBG0("[%s] dev:%s\n", __func__, dev->name);
skb = __dev_alloc_skb(size, GFP_ATOMIC);
if (skb == NULL) {
DBG0("%s: unable to alloc skb\n", __func__);
return -ENOMEM;
}
/* TODO skb_reserve(skb, NET_IP_ALIGN); for ethernet mode */
/* Populate some params now. */
skb->dev = dev;
ptr = skb_put(skb, size);
skb_set_network_header(skb, 0);
/* done with skb setup, return the buffer pointer. */
*pkt_priv = skb;
*buffer = ptr;
return 0;
}
static struct sk_buff *osl_alloc_skb(unsigned int len)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
return __dev_alloc_skb(len, GFP_ATOMIC);
#else
return dev_alloc_skb(len);
#endif
}
/**
* dev_alloc_skb - allocate an skbuff for receiving
* @length: length to allocate
*
* Allocate a new &sk_buff and assign it a usage count of one. The
* buffer has unspecified headroom built in. Users should allocate
* the headroom they think they need without accounting for the
* built in space. The built in space is used for optimisations.
*
* %NULL is returned if there is no free memory. Although this function
* allocates memory it can be called from an interrupt.
*/
struct sk_buff *dev_alloc_skb(unsigned int length)
{
/*
* There is more code here than it seems:
* __dev_alloc_skb is an
*/
return __dev_alloc_skb(length, GFP_ATOMIC);
}
struct SimDevicePacket lib_dev_create_packet(struct SimDevice *dev, int size)
{
struct SimDevicePacket packet;
int len = get_hack_size(size);
struct sk_buff *skb = __dev_alloc_skb(len, __GFP_WAIT);
packet.token = skb;
packet.buffer = skb_put(skb, len);
return packet;
}
inline struct sk_buff *_rtw_skb_alloc(u32 sz)
{
#ifdef PLATFORM_LINUX
return __dev_alloc_skb(sz, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
#endif /* PLATFORM_LINUX */
#ifdef PLATFORM_FREEBSD
return dev_alloc_skb(sz);
#endif /* PLATFORM_FREEBSD */
}
static struct sk_buff *osl_alloc_skb(unsigned int len)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
gfp_t flags = (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL;
return __dev_alloc_skb(len, flags);
#else
return dev_alloc_skb(len);
#endif
}
static struct recv_buf* sd_recv_rxfifo(PADAPTER padapter, u32 size)
{
u32 readsize, allocsize, ret;
u8 *preadbuf;
_pkt *ppkt;
struct recv_priv *precvpriv;
struct recv_buf *precvbuf;
readsize = size;
//3 1. alloc skb
// align to block size
allocsize = _RND(readsize, adapter_to_dvobj(padapter)->intf_data.block_transfer_len);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) // http://www.mail-archive.com/[email protected]/msg17214.html
ppkt = __dev_alloc_skb(allocsize, GFP_KERNEL);
#else
ppkt = __netdev_alloc_skb(padapter->pnetdev, allocsize, GFP_KERNEL);
#endif
if (ppkt == NULL) {
RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("%s: alloc_skb fail! alloc=%d read=%d\n", __FUNCTION__, allocsize, readsize));
return NULL;
}
//3 2. read data from rxfifo
preadbuf = skb_put(ppkt, readsize);
// rtw_read_port(padapter, WLAN_RX0FF_DEVICE_ID, readsize, preadbuf);
ret = sdio_read_port(&padapter->iopriv.intf, WLAN_RX0FF_DEVICE_ID, readsize, preadbuf);
if (ret == _FAIL) {
dev_kfree_skb_any(ppkt);
RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("%s: read port FAIL!\n", __FUNCTION__));
return NULL;
}
//3 3. alloc recvbuf
precvpriv = &padapter->recvpriv;
precvbuf = rtw_dequeue_recvbuf(&precvpriv->free_recv_buf_queue);
if (precvbuf == NULL) {
dev_kfree_skb_any(ppkt);
RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("%s: alloc recvbuf FAIL!\n", __FUNCTION__));
return NULL;
}
//3 4. init recvbuf
precvbuf->pskb = ppkt;
precvbuf->len = ppkt->len;
precvbuf->phead = ppkt->head;
precvbuf->pdata = ppkt->data;
precvbuf->ptail = skb_tail_pointer(precvbuf->pskb);
precvbuf->pend = skb_end_pointer(precvbuf->pskb);
return precvbuf;
}
struct sk_buff *r92su_h2c_alloc(struct r92su *r92su, int len, gfp_t flag)
{
struct sk_buff *skb;
unsigned int new_len =
ALIGN(len + TX_DESC_SIZE + H2CC2H_HDR_LEN, H2CC2H_HDR_LEN);
skb = __dev_alloc_skb(new_len, flag);
if (skb)
skb_reserve(skb, TX_DESC_SIZE + H2CC2H_HDR_LEN);
return skb;
}
static struct sk_buff *osl_alloc_skb(osl_t *osh, unsigned int len)
{
struct sk_buff *skb;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
gfp_t flags = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
skb = __dev_alloc_skb(len, flags);
#else
skb = dev_alloc_skb(len);
#endif
return skb;
}
static void queue_rx(void)
{
void *ptr;
rx_skb = __dev_alloc_skb(BUFFER_SIZE, GFP_KERNEL);
ptr = skb_put(rx_skb, BUFFER_SIZE);
/* need a way to handle error case */
rx_skb_dma_addr = dma_map_single(NULL, ptr, BUFFER_SIZE,
DMA_FROM_DEVICE);
sps_transfer_one(bam_rx_pipe, rx_skb_dma_addr,
BUFFER_SIZE, NULL,
SPS_IOVEC_FLAG_INT | SPS_IOVEC_FLAG_EOT);
}
static struct sk_buff *osl_alloc_skb(unsigned int len)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
gfp_t flags = GFP_ATOMIC;
struct sk_buff *skb;
skb = __dev_alloc_skb(len, flags);
return skb;
#else
return dev_alloc_skb(len);
#endif
}
static void wl1251_rx_body(struct wl1251 *wl,
struct wl1251_rx_descriptor *desc)
{
struct sk_buff *skb;
struct ieee80211_rx_status status;
u8 *rx_buffer, beacon = 0;
u16 length, *fc;
u32 curr_id, last_id_inc, rx_packet_ring_addr;
length = WL1251_RX_ALIGN(desc->length - PLCP_HEADER_LENGTH);
curr_id = (desc->flags & RX_DESC_SEQNUM_MASK) >> RX_DESC_PACKETID_SHIFT;
last_id_inc = (wl->rx_last_id + 1) % (RX_MAX_PACKET_ID + 1);
if (last_id_inc != curr_id) {
wl1251_warning("curr ID:%d, last ID inc:%d",
curr_id, last_id_inc);
wl->rx_last_id = curr_id;
} else {
wl->rx_last_id = last_id_inc;
}
rx_packet_ring_addr = wl->data_path->rx_packet_ring_addr +
sizeof(struct wl1251_rx_descriptor) + 20;
if (wl->rx_current_buffer)
rx_packet_ring_addr += wl->data_path->rx_packet_ring_chunk_size;
skb = __dev_alloc_skb(length, GFP_KERNEL);
if (!skb) {
wl1251_error("Couldn't allocate RX frame");
return;
}
rx_buffer = skb_put(skb, length);
wl1251_mem_read(wl, rx_packet_ring_addr, rx_buffer, length);
/* The actual length doesn't include the target's alignment */
skb_trim(skb, desc->length - PLCP_HEADER_LENGTH);
fc = (u16 *)skb->data;
if ((*fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_BEACON)
beacon = 1;
wl1251_rx_status(wl, desc, &status, beacon);
wl1251_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb, skb->len,
beacon ? "beacon" : "");
memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
ieee80211_rx_ni(wl->hw, skb);
wl1251_update_rate(wl, length);
}
static int setup_rx_descbuffer(struct b43_dmaring *ring,
struct b43_dmadesc_generic *desc,
struct b43_dmadesc_meta *meta, gfp_t gfp_flags)
{
dma_addr_t dmaaddr;
struct sk_buff *skb;
B43_WARN_ON(ring->tx);
skb = __dev_alloc_skb(ring->rx_buffersize, gfp_flags);
if (unlikely(!skb))
return -ENOMEM;
b43_poison_rx_buffer(ring, skb);
dmaaddr = map_descbuffer(ring, skb->data, ring->rx_buffersize, 0);
if (b43_dma_mapping_error(ring, dmaaddr, ring->rx_buffersize, 0)) {
/* ugh. try to realloc in zone_dma */
gfp_flags |= GFP_DMA;
dev_kfree_skb_any(skb);
skb = __dev_alloc_skb(ring->rx_buffersize, gfp_flags);
if (unlikely(!skb))
return -ENOMEM;
b43_poison_rx_buffer(ring, skb);
dmaaddr = map_descbuffer(ring, skb->data,
ring->rx_buffersize, 0);
if (b43_dma_mapping_error(ring, dmaaddr, ring->rx_buffersize, 0)) {
b43err(ring->dev->wl, "RX DMA buffer allocation failed\n");
dev_kfree_skb_any(skb);
return -EIO;
}
}
meta->skb = skb;
meta->dmaaddr = dmaaddr;
ring->ops->fill_descriptor(ring, desc, dmaaddr,
ring->rx_buffersize, 0, 0, 0);
return 0;
}
static struct sk_buff *osl_alloc_skb(osl_t *osh, unsigned int len)
{
struct sk_buff *skb;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
gfp_t flags = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
#if defined(CONFIG_SPARSEMEM) && defined(CONFIG_ZONE_DMA)
flags |= GFP_ATOMIC;
#endif
skb = __dev_alloc_skb(len, flags);
#else
skb = dev_alloc_skb(len);
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25) */
return skb;
}
static int wl1271_rx_handle_data(struct wl1271 *wl, u8 *data, u32 length)
{
struct wl1271_rx_descriptor *desc;
struct sk_buff *skb;
struct ieee80211_hdr *hdr;
u8 *buf;
u8 beacon = 0;
u8 is_data = 0;
/*
* In PLT mode we seem to get frames and mac80211 warns about them,
* workaround this by not retrieving them at all.
*/
if (unlikely(wl->state == WL1271_STATE_PLT))
return -EINVAL;
skb = __dev_alloc_skb(length, GFP_KERNEL);
if (!skb) {
wl1271_error("Couldn't allocate RX frame");
return -ENOMEM;
}
buf = skb_put(skb, length);
memcpy(buf, data, length);
/* the data read starts with the descriptor */
desc = (struct wl1271_rx_descriptor *) buf;
/* now we pull the descriptor out of the buffer */
skb_pull(skb, sizeof(*desc));
hdr = (struct ieee80211_hdr *)skb->data;
if (ieee80211_is_beacon(hdr->frame_control))
beacon = 1;
if (ieee80211_is_data_present(hdr->frame_control))
is_data = 1;
wl1271_rx_status(wl, desc, IEEE80211_SKB_RXCB(skb), beacon);
wl1271_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb, skb->len,
beacon ? "beacon" : "");
skb_trim(skb, skb->len - desc->pad_len);
skb_queue_tail(&wl->deferred_rx_queue, skb);
ieee80211_queue_work(wl->hw, &wl->netstack_work);
return is_data;
}
static void __16_reload_work(struct work_struct *work)
{
struct sk_buff *skb;
CCCI_DBG_MSG(-1, BM, "refill 16B skb pool\n");
while(skb_pool_16.skb_list.qlen < SKB_POOL_SIZE_16) {
skb = dev_alloc_skb(SKB_16);
if(!skb)
skb = __dev_alloc_skb(SKB_16, GFP_KERNEL);
if(skb)
skb_queue_tail(&skb_pool_16.skb_list, skb);
else
CCCI_ERR_MSG(-1, BM, "fail to reload 16B pool\n");
}
}
static int __init rtw_mem_init(void)
{
int i;
u32 max_recvbuf_sz = 0;
SIZE_PTR tmpaddr=0;
SIZE_PTR alignment=0;
struct sk_buff *pskb=NULL;
printk("%s\n", __func__);
#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
for(i=0; i<NR_RECVBUFF; i++)
{
rtk_buf_mem[i] = usb_buffer_alloc(dev, size, (in_interrupt() ? GFP_ATOMIC : GFP_KERNEL), dma);
}
#endif //CONFIG_USE_USB_BUFFER_ALLOC_RX
skb_queue_head_init(&rtk_skb_mem_q);
rtw_hal_get_def_var(padapter, HAL_DEF_MAX_RECVBUF_SZ, &max_recvbuf_sz);
if (max_recvbuf_sz == 0)
max_recvbuf_sz = MAX_RECVBUF_SZ;
DBG_871X("%s: max_recvbuf_sz: %d\n", __func__, max_recvbuf_sz);
for(i=0; i<NR_PREALLOC_RECV_SKB; i++)
{
pskb = __dev_alloc_skb(max_recvbuf_sz + RECVBUFF_ALIGN_SZ, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
if(pskb)
{
tmpaddr = (SIZE_PTR)pskb->data;
alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
skb_reserve(pskb, (RECVBUFF_ALIGN_SZ - alignment));
skb_queue_tail(&rtk_skb_mem_q, pskb);
}
else
{
printk("%s, alloc skb memory fail!\n", __func__);
}
pskb=NULL;
}
printk("%s, rtk_skb_mem_q len : %d\n", __func__, skb_queue_len(&rtk_skb_mem_q));
return 0;
}
struct sk_buff *os_alloc_skb(void){
int offset=0;
struct sk_buff *skb = __dev_alloc_skb(NLM_RX_BUF_SIZE, GFP_KERNEL);
if (!skb) {
return NULL;
}
/* align the data to the next cache line */
offset = ((unsigned long)skb->data + SMP_CACHE_BYTES) &
~(SMP_CACHE_BYTES - 1);
skb_reserve(skb, (offset - (unsigned long)skb->data));
return skb;
}
static int qtnf_ep_fw_send(struct qtnf_pcie_bus_priv *priv, uint32_t size,
int blk, const u8 *pblk, const u8 *fw)
{
struct pci_dev *pdev = priv->pdev;
struct qtnf_bus *bus = pci_get_drvdata(pdev);
struct qtnf_pcie_fw_hdr *hdr;
u8 *pdata;
int hds = sizeof(*hdr);
struct sk_buff *skb = NULL;
int len = 0;
int ret;
skb = __dev_alloc_skb(QTN_PCIE_FW_BUFSZ, GFP_KERNEL);
if (!skb)
return -ENOMEM;
skb->len = QTN_PCIE_FW_BUFSZ;
skb->dev = NULL;
hdr = (struct qtnf_pcie_fw_hdr *)skb->data;
memcpy(hdr->boardflg, QTN_PCIE_BOARDFLG, strlen(QTN_PCIE_BOARDFLG));
hdr->fwsize = cpu_to_le32(size);
hdr->seqnum = cpu_to_le32(blk);
if (blk)
hdr->type = cpu_to_le32(QTN_FW_DSUB);
else
hdr->type = cpu_to_le32(QTN_FW_DBEGIN);
pdata = skb->data + hds;
len = QTN_PCIE_FW_BUFSZ - hds;
if (pblk >= (fw + size - len)) {
len = fw + size - pblk;
hdr->type = cpu_to_le32(QTN_FW_DEND);
}
hdr->pktlen = cpu_to_le32(len);
memcpy(pdata, pblk, len);
hdr->crc = cpu_to_le32(~crc32(0, pdata, len));
ret = qtnf_pcie_data_tx(bus, skb);
return (ret == NETDEV_TX_OK) ? len : 0;
}
void*
osl_pktget(osl_t *osh, uint len)
{
struct sk_buff *skb;
gfp_t flags;
flags = (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL;
if ((skb = __dev_alloc_skb(len, flags))) {
skb_put(skb, len);
skb->priority = 0;
osh->pub.pktalloced++;
}
return ((void*) skb);
}
