CORE/EPPING/src/epping_helper.c - imx-board-wlan-src - Git at Google

 /*
  * Copyright (c) 2014, 2016-2017 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
  * above copyright notice and this permission notice appear in all
  * copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */

 /*
  * This file was originally distributed by Qualcomm Atheros, Inc.
  * under proprietary terms before Copyright ownership was assigned
  * to the Linux Foundation.
  */

 /*========================================================================

   \file  epping_main.c

   \brief WLAN End Point Ping test tool implementation

   ========================================================================*/

 /*--------------------------------------------------------------------------
   Include Files
   ------------------------------------------------------------------------*/
 #include <wlan_hdd_includes.h>
 #include <vos_api.h>
 #include <vos_sched.h>
 #include <linux/etherdevice.h>
 #include <linux/firmware.h>
 #include <linux/delay.h>
 #include <wcnss_api.h>
 #include <wlan_hdd_tx_rx.h>
 #include <wniApi.h>
 #include <wlan_nlink_srv.h>
 #include <wlan_hdd_cfg.h>
 #include <wlan_ptt_sock_svc.h>
 #include <wlan_hdd_wowl.h>
 #include <wlan_hdd_misc.h>
 #include <wlan_hdd_wext.h>
 #include <linux/wireless.h>
 #include <net/cfg80211.h>
 #include <linux/rtnetlink.h>
 #include <linux/semaphore.h>
 #include <linux/delay.h>
 #include <linux/ctype.h>
 #include <wlan_hdd_hostapd.h>
 #include <wlan_hdd_softap_tx_rx.h>
 #include "epping_main.h"
 #include "epping_internal.h"

 int epping_cookie_init(epping_context_t*pEpping_ctx)
 {
    A_UINT32 i, j;

    pEpping_ctx->cookie_list = NULL;
    pEpping_ctx->cookie_count = 0;
    for (i = 0; i < MAX_COOKIE_SLOTS_NUM; i++) {
       pEpping_ctx->s_cookie_mem[i] =
          vos_mem_malloc(sizeof(struct epping_cookie)*MAX_COOKIE_SLOT_SIZE);
       if (pEpping_ctx->s_cookie_mem[i] == NULL) {
          EPPING_LOG(VOS_TRACE_LEVEL_FATAL,
             "%s: no mem for cookie (idx = %d)", __func__, i);
          goto error;
       }
       vos_mem_zero(pEpping_ctx->s_cookie_mem[i],
          sizeof(struct epping_cookie)*MAX_COOKIE_SLOT_SIZE);
    }
    adf_os_spinlock_init(&pEpping_ctx->cookie_lock);

    for (i = 0; i < MAX_COOKIE_SLOTS_NUM; i++) {
       struct epping_cookie *cookie_mem = pEpping_ctx->s_cookie_mem[i];
       for (j = 0; j < MAX_COOKIE_SLOT_SIZE; j++) {
          epping_free_cookie(pEpping_ctx, &cookie_mem[j]);
       }
    }
    return 0;
 error:
    for (i = 0; i < MAX_COOKIE_SLOTS_NUM; i++) {
       if (pEpping_ctx->s_cookie_mem[i]) {
          vos_mem_free(pEpping_ctx->s_cookie_mem[i]);
          pEpping_ctx->s_cookie_mem[i] = NULL;
       }
    }
    return -ENOMEM;
 }

 /* cleanup cookie queue */
 void epping_cookie_cleanup(epping_context_t*pEpping_ctx)
 {
    int i;
    adf_os_spin_lock_bh(&pEpping_ctx->cookie_lock);
    pEpping_ctx->cookie_list = NULL;
    pEpping_ctx->cookie_count = 0;
    adf_os_spin_unlock_bh(&pEpping_ctx->cookie_lock);
    for (i = 0; i < MAX_COOKIE_SLOTS_NUM; i++) {
       if (pEpping_ctx->s_cookie_mem[i]) {
          vos_mem_free(pEpping_ctx->s_cookie_mem[i]);
          pEpping_ctx->s_cookie_mem[i] = NULL;
       }
    }
 }

 void epping_free_cookie(epping_context_t*pEpping_ctx,
                         struct epping_cookie *cookie)
 {
    adf_os_spin_lock_bh(&pEpping_ctx->cookie_lock);
    cookie->next = pEpping_ctx->cookie_list;
    pEpping_ctx->cookie_list = cookie;
    pEpping_ctx->cookie_count++;
    adf_os_spin_unlock_bh(&pEpping_ctx->cookie_lock);
 }

 struct epping_cookie *epping_alloc_cookie(epping_context_t*pEpping_ctx)
 {
    struct epping_cookie   *cookie;

    adf_os_spin_lock_bh(&pEpping_ctx->cookie_lock);
    cookie = pEpping_ctx->cookie_list;
    if(cookie != NULL)
    {
       pEpping_ctx->cookie_list = cookie->next;
       pEpping_ctx->cookie_count--;
    }
    adf_os_spin_unlock_bh(&pEpping_ctx->cookie_lock);
    return cookie;
 }

 void epping_get_dummy_mac_addr(tSirMacAddr macAddr)
 {
    macAddr[0] = 69; /* E */
    macAddr[1] = 80; /* P */
    macAddr[2] = 80; /* P */
    macAddr[3] = 73; /* I */
    macAddr[4] = 78; /* N */
    macAddr[5] = 71; /* G */
 }

 void epping_hex_dump(void *data, int buf_len, const char *str)
 {
    char *buf = (char *)data;
    int i;

    printk("%s: E, %s\n", __func__, str);
    for (i=0; (i+7)< buf_len; i+=8)
    {
       printk("%02x %02x %02x %02x %02x %02x %02x %02x\n",
          buf[i],
          buf[i+1],
          buf[i+2],
          buf[i+3],
          buf[i+4],
          buf[i+5],
          buf[i+6],
          buf[i+7]);
    }

    // Dump the bytes in the last line
    for (; i < buf_len; i++)
    {
       printk("%02x ", buf[i]);
    }
    printk("\n%s: X %s\n", __func__, str);
 }


 void *epping_get_adf_ctx(void)
 {
    VosContextType *pVosContext = NULL;
    adf_os_device_t *pAdfCtx;
    pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS, NULL);
    pAdfCtx = vos_get_context(VOS_MODULE_ID_ADF, pVosContext);
    return pAdfCtx;
 }

 void epping_log_packet(epping_adapter_t *pAdapter,
                        EPPING_HEADER *eppingHdr, int ret, const char *str)
 {
    if (eppingHdr->Cmd_h & EPPING_LOG_MASK) {
       EPPING_LOG(VOS_TRACE_LEVEL_FATAL,
          "%s: cmd = %d, seqNo = %u, flag = 0x%x, ret = %d, "
          "txCount = %lu, txDrop =  %lu, txBytes = %lu,"
          "rxCount = %lu, rxDrop = %lu, rxBytes = %lu\n",
          str, eppingHdr->Cmd_h, eppingHdr->SeqNo,
          eppingHdr->CmdFlags_h, ret,
          pAdapter->stats.tx_packets,
          pAdapter->stats.tx_dropped,
          pAdapter->stats.tx_bytes,
          pAdapter->stats.rx_packets,
          pAdapter->stats.rx_dropped,
          pAdapter->stats.rx_bytes);
    }
 }

 void epping_log_stats(epping_adapter_t *pAdapter, const char *str)
 {
    EPPING_LOG(VOS_TRACE_LEVEL_FATAL,
       "%s: txCount = %lu, txDrop = %lu, tx_bytes = %lu, "
       "rxCount = %lu, rxDrop = %lu, rx_bytes = %lu, tx_acks = %u\n",
       str,
       pAdapter->stats.tx_packets,
       pAdapter->stats.tx_dropped,
       pAdapter->stats.tx_bytes,
       pAdapter->stats.rx_packets,
       pAdapter->stats.rx_dropped,
       pAdapter->stats.rx_bytes,
       pAdapter->pEpping_ctx->total_tx_acks);
 }

 void epping_set_kperf_flag(epping_adapter_t *pAdapter,
                            HTC_ENDPOINT_ID eid,
                            A_UINT8 kperf_flag)
 {
    pAdapter->pEpping_ctx->kperf[eid] = kperf_flag;
    pAdapter->pEpping_ctx->kperf_num_rx_recv[eid] = 0;
    pAdapter->pEpping_ctx->kperf_num_tx_acks[eid] = 0;
 }

 #ifdef HIF_PCI

 static int epping_tx_thread_fn(void *data)
 {
     int i;
    epping_poll_t *epping_poll = data;

    EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: arg = %pK", __func__, data);
    while (!epping_poll->done) {
       down(&epping_poll->sem);
       adf_os_atomic_dec(&epping_poll->atm);
       if (epping_poll->skb && !epping_poll->done) {
          for (i = 0; i < MAX_TX_PKT_DUP_NUM; i++) {
             epping_tx_dup_pkt((epping_adapter_t *)epping_poll->arg,
                epping_poll->eid, epping_poll->skb);
             udelay(WLAN_EPPING_DELAY_TIMEOUT_US);
          }
       }
    }
    return 0;
 }

 #define EPPING_TX_THREAD "EPPINGTX"
 void epping_register_tx_copier(HTC_ENDPOINT_ID eid, epping_context_t *pEpping_ctx)
 {
    epping_poll_t *epping_poll = &pEpping_ctx->epping_poll[eid];
    epping_poll->eid = eid;
    epping_poll->arg = pEpping_ctx->epping_adapter;
    epping_poll->done = false;
    EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: eid = %d, arg = %pK",
               __func__, eid, pEpping_ctx->epping_adapter);
    sema_init(&epping_poll->sem, 0);
    adf_os_atomic_init(&epping_poll->atm);
    epping_poll->inited = true;
    epping_poll->pid = kthread_create(epping_tx_thread_fn,
                                      epping_poll, EPPING_TX_THREAD);
    wake_up_process(epping_poll->pid);
 }
 void epping_unregister_tx_copier(HTC_ENDPOINT_ID eid, epping_context_t *pEpping_ctx)
 {
    epping_poll_t *epping_poll;

    if (eid < 0 || eid >= EPPING_MAX_NUM_EPIDS ) {
       EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: invalid eid = %d",
          __func__, eid);
       return;
    }

    epping_poll = &pEpping_ctx->epping_poll[eid];

    epping_poll->done = true;
    if (epping_poll->inited) {
       epping_tx_copier_schedule(pEpping_ctx, eid, NULL);
       msleep(EPPING_KTID_KILL_WAIT_TIME_MS);
    }
    if (epping_poll->skb)
       adf_nbuf_free(epping_poll->skb);
    OS_MEMZERO(epping_poll, sizeof(epping_poll_t));
    EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: eid = %d",
                __func__, eid);
 }
 void epping_tx_copier_schedule(epping_context_t *pEpping_ctx, HTC_ENDPOINT_ID eid, adf_nbuf_t skb)
 {
    epping_poll_t *epping_poll = &pEpping_ctx->epping_poll[eid];

    if (!epping_poll->skb && skb) {
       epping_poll->skb = adf_nbuf_copy(skb);
    }
    if (adf_os_atomic_read(&epping_poll->atm) < EPPING_MAX_WATER_MARK) {
       adf_os_atomic_inc(&epping_poll->atm);
       up(&epping_poll->sem);
    }
 }
 #endif /* HIF_PCI */
	/*
	* Copyright (c) 2014, 2016-2017 The Linux Foundation. All rights reserved.
	*
	* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
	*
	*
	* Permission to use, copy, modify, and/or distribute this software for
	* any purpose with or without fee is hereby granted, provided that the
	* above copyright notice and this permission notice appear in all
	* copies.
	*
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
	* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
	* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
	* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
	* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
	* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	* PERFORMANCE OF THIS SOFTWARE.
	*/

	/*
	* This file was originally distributed by Qualcomm Atheros, Inc.
	* under proprietary terms before Copyright ownership was assigned
	* to the Linux Foundation.
	*/

	/*========================================================================

	\file epping_main.c

	\brief WLAN End Point Ping test tool implementation

	========================================================================*/

	/*--------------------------------------------------------------------------
	Include Files
	------------------------------------------------------------------------*/
	#include <wlan_hdd_includes.h>
	#include <vos_api.h>
	#include <vos_sched.h>
	#include <linux/etherdevice.h>
	#include <linux/firmware.h>
	#include <linux/delay.h>
	#include <wcnss_api.h>
	#include <wlan_hdd_tx_rx.h>
	#include <wniApi.h>
	#include <wlan_nlink_srv.h>
	#include <wlan_hdd_cfg.h>
	#include <wlan_ptt_sock_svc.h>
	#include <wlan_hdd_wowl.h>
	#include <wlan_hdd_misc.h>
	#include <wlan_hdd_wext.h>
	#include <linux/wireless.h>
	#include <net/cfg80211.h>
	#include <linux/rtnetlink.h>
	#include <linux/semaphore.h>
	#include <linux/delay.h>
	#include <linux/ctype.h>
	#include <wlan_hdd_hostapd.h>
	#include <wlan_hdd_softap_tx_rx.h>
	#include "epping_main.h"
	#include "epping_internal.h"

	int epping_cookie_init(epping_context_t*pEpping_ctx)
	{
	A_UINT32 i, j;

	pEpping_ctx->cookie_list = NULL;
	pEpping_ctx->cookie_count = 0;
	for (i = 0; i < MAX_COOKIE_SLOTS_NUM; i++) {
	pEpping_ctx->s_cookie_mem[i] =
	vos_mem_malloc(sizeof(struct epping_cookie)*MAX_COOKIE_SLOT_SIZE);
	if (pEpping_ctx->s_cookie_mem[i] == NULL) {
	EPPING_LOG(VOS_TRACE_LEVEL_FATAL,
	"%s: no mem for cookie (idx = %d)", __func__, i);
	goto error;
	}
	vos_mem_zero(pEpping_ctx->s_cookie_mem[i],
	sizeof(struct epping_cookie)*MAX_COOKIE_SLOT_SIZE);
	}
	adf_os_spinlock_init(&pEpping_ctx->cookie_lock);

	for (i = 0; i < MAX_COOKIE_SLOTS_NUM; i++) {
	struct epping_cookie *cookie_mem = pEpping_ctx->s_cookie_mem[i];
	for (j = 0; j < MAX_COOKIE_SLOT_SIZE; j++) {
	epping_free_cookie(pEpping_ctx, &cookie_mem[j]);
	}
	}
	return 0;
	error:
	for (i = 0; i < MAX_COOKIE_SLOTS_NUM; i++) {
	if (pEpping_ctx->s_cookie_mem[i]) {
	vos_mem_free(pEpping_ctx->s_cookie_mem[i]);
	pEpping_ctx->s_cookie_mem[i] = NULL;
	}
	}
	return -ENOMEM;
	}

	/* cleanup cookie queue */
	void epping_cookie_cleanup(epping_context_t*pEpping_ctx)
	{
	int i;
	adf_os_spin_lock_bh(&pEpping_ctx->cookie_lock);
	pEpping_ctx->cookie_list = NULL;
	pEpping_ctx->cookie_count = 0;
	adf_os_spin_unlock_bh(&pEpping_ctx->cookie_lock);
	for (i = 0; i < MAX_COOKIE_SLOTS_NUM; i++) {
	if (pEpping_ctx->s_cookie_mem[i]) {
	vos_mem_free(pEpping_ctx->s_cookie_mem[i]);
	pEpping_ctx->s_cookie_mem[i] = NULL;
	}
	}
	}

	void epping_free_cookie(epping_context_t*pEpping_ctx,
	struct epping_cookie *cookie)
	{
	adf_os_spin_lock_bh(&pEpping_ctx->cookie_lock);
	cookie->next = pEpping_ctx->cookie_list;
	pEpping_ctx->cookie_list = cookie;
	pEpping_ctx->cookie_count++;
	adf_os_spin_unlock_bh(&pEpping_ctx->cookie_lock);
	}

	struct epping_cookie epping_alloc_cookie(epping_context_tpEpping_ctx)
	{
	struct epping_cookie *cookie;

	adf_os_spin_lock_bh(&pEpping_ctx->cookie_lock);
	cookie = pEpping_ctx->cookie_list;
	if(cookie != NULL)
	{
	pEpping_ctx->cookie_list = cookie->next;
	pEpping_ctx->cookie_count--;
	}
	adf_os_spin_unlock_bh(&pEpping_ctx->cookie_lock);
	return cookie;
	}

	void epping_get_dummy_mac_addr(tSirMacAddr macAddr)
	{
	macAddr[0] = 69; /* E */
	macAddr[1] = 80; /* P */
	macAddr[2] = 80; /* P */
	macAddr[3] = 73; /* I */
	macAddr[4] = 78; /* N */
	macAddr[5] = 71; /* G */
	}

	void epping_hex_dump(void data, int buf_len, const char str)
	{
	char buf = (char )data;
	int i;

	printk("%s: E, %s\n", __func__, str);
	for (i=0; (i+7)< buf_len; i+=8)
	{
	printk("%02x %02x %02x %02x %02x %02x %02x %02x\n",
	buf[i],
	buf[i+1],
	buf[i+2],
	buf[i+3],
	buf[i+4],
	buf[i+5],
	buf[i+6],
	buf[i+7]);
	}

	// Dump the bytes in the last line
	for (; i < buf_len; i++)
	{
	printk("%02x ", buf[i]);
	}
	printk("\n%s: X %s\n", __func__, str);
	}


	void *epping_get_adf_ctx(void)
	{
	VosContextType *pVosContext = NULL;
	adf_os_device_t *pAdfCtx;
	pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS, NULL);
	pAdfCtx = vos_get_context(VOS_MODULE_ID_ADF, pVosContext);
	return pAdfCtx;
	}

	void epping_log_packet(epping_adapter_t *pAdapter,
	EPPING_HEADER eppingHdr, int ret, const char str)
	{
	if (eppingHdr->Cmd_h & EPPING_LOG_MASK) {
	EPPING_LOG(VOS_TRACE_LEVEL_FATAL,
	"%s: cmd = %d, seqNo = %u, flag = 0x%x, ret = %d, "
	"txCount = %lu, txDrop = %lu, txBytes = %lu,"
	"rxCount = %lu, rxDrop = %lu, rxBytes = %lu\n",
	str, eppingHdr->Cmd_h, eppingHdr->SeqNo,
	eppingHdr->CmdFlags_h, ret,
	pAdapter->stats.tx_packets,
	pAdapter->stats.tx_dropped,
	pAdapter->stats.tx_bytes,
	pAdapter->stats.rx_packets,
	pAdapter->stats.rx_dropped,
	pAdapter->stats.rx_bytes);
	}
	}

	void epping_log_stats(epping_adapter_t pAdapter, const char str)
	{
	EPPING_LOG(VOS_TRACE_LEVEL_FATAL,
	"%s: txCount = %lu, txDrop = %lu, tx_bytes = %lu, "
	"rxCount = %lu, rxDrop = %lu, rx_bytes = %lu, tx_acks = %u\n",
	str,
	pAdapter->stats.tx_packets,
	pAdapter->stats.tx_dropped,
	pAdapter->stats.tx_bytes,
	pAdapter->stats.rx_packets,
	pAdapter->stats.rx_dropped,
	pAdapter->stats.rx_bytes,
	pAdapter->pEpping_ctx->total_tx_acks);
	}

	void epping_set_kperf_flag(epping_adapter_t *pAdapter,
	HTC_ENDPOINT_ID eid,
	A_UINT8 kperf_flag)
	{
	pAdapter->pEpping_ctx->kperf[eid] = kperf_flag;
	pAdapter->pEpping_ctx->kperf_num_rx_recv[eid] = 0;
	pAdapter->pEpping_ctx->kperf_num_tx_acks[eid] = 0;
	}

	#ifdef HIF_PCI

	static int epping_tx_thread_fn(void *data)
	{
	int i;
	epping_poll_t *epping_poll = data;

	EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: arg = %pK", __func__, data);
	while (!epping_poll->done) {
	down(&epping_poll->sem);
	adf_os_atomic_dec(&epping_poll->atm);
	if (epping_poll->skb && !epping_poll->done) {
	for (i = 0; i < MAX_TX_PKT_DUP_NUM; i++) {
	epping_tx_dup_pkt((epping_adapter_t *)epping_poll->arg,
	epping_poll->eid, epping_poll->skb);
	udelay(WLAN_EPPING_DELAY_TIMEOUT_US);
	}
	}
	}
	return 0;
	}

	#define EPPING_TX_THREAD "EPPINGTX"
	void epping_register_tx_copier(HTC_ENDPOINT_ID eid, epping_context_t *pEpping_ctx)
	{
	epping_poll_t *epping_poll = &pEpping_ctx->epping_poll[eid];
	epping_poll->eid = eid;
	epping_poll->arg = pEpping_ctx->epping_adapter;
	epping_poll->done = false;
	EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: eid = %d, arg = %pK",
	__func__, eid, pEpping_ctx->epping_adapter);
	sema_init(&epping_poll->sem, 0);
	adf_os_atomic_init(&epping_poll->atm);
	epping_poll->inited = true;
	epping_poll->pid = kthread_create(epping_tx_thread_fn,
	epping_poll, EPPING_TX_THREAD);
	wake_up_process(epping_poll->pid);
	}
	void epping_unregister_tx_copier(HTC_ENDPOINT_ID eid, epping_context_t *pEpping_ctx)
	{
	epping_poll_t *epping_poll;

	if (eid < 0 \|\| eid >= EPPING_MAX_NUM_EPIDS ) {
	EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: invalid eid = %d",
	__func__, eid);
	return;
	}

	epping_poll = &pEpping_ctx->epping_poll[eid];

	epping_poll->done = true;
	if (epping_poll->inited) {
	epping_tx_copier_schedule(pEpping_ctx, eid, NULL);
	msleep(EPPING_KTID_KILL_WAIT_TIME_MS);
	}
	if (epping_poll->skb)
	adf_nbuf_free(epping_poll->skb);
	OS_MEMZERO(epping_poll, sizeof(epping_poll_t));
	EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: eid = %d",
	__func__, eid);
	}
	void epping_tx_copier_schedule(epping_context_t *pEpping_ctx, HTC_ENDPOINT_ID eid, adf_nbuf_t skb)
	{
	epping_poll_t *epping_poll = &pEpping_ctx->epping_poll[eid];

	if (!epping_poll->skb && skb) {
	epping_poll->skb = adf_nbuf_copy(skb);
	}
	if (adf_os_atomic_read(&epping_poll->atm) < EPPING_MAX_WATER_MARK) {
	adf_os_atomic_inc(&epping_poll->atm);
	up(&epping_poll->sem);
	}
	}
	#endif /* HIF_PCI */