samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Rename pAdapter in epping

Browse Source 
The Linux Coding Style frowns upon mixed-case names and
so-called Hungarian notation, so rename pAdapter to align
with the Coding Style.

Change-Id: Iddd543a9e0fb61a92e0769abb234b93e44f603c2
CRs-Fixed: 2119798
This commit is contained in:
Jeff Johnson
2017-10-02 14:05:29 -07:00
committed by snandini
parent b80af7e971
commit 6a7f21d9e6
5 changed files with 181 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
utils/epping/inc/epping_internal.h
View File

@@ -159,22 +159,22 @@ struct epping_cookie *epping_alloc_cookie(epping_context_t *pEpping_ctx);
void epping_get_dummy_mac_addr(tSirMacAddr macAddr);
void epping_hex_dump(void *data, int buf_len, const char *str);
void *epping_get_qdf_ctx(void);
void epping_log_packet(epping_adapter_t *pAdapter,
void epping_log_packet(epping_adapter_t *adapter,
EPPING_HEADER *eppingHdr, int ret, const char *str);
void epping_log_stats(epping_adapter_t *pAdapter, const char *str);
void epping_set_kperf_flag(epping_adapter_t *pAdapter,
void epping_log_stats(epping_adapter_t *adapter, const char *str);
void epping_set_kperf_flag(epping_adapter_t *adapter,
HTC_ENDPOINT_ID eid, A_UINT8 kperf_flag);
/* epping_tx signatures */
void epping_tx_timer_expire(epping_adapter_t *pAdapter);
void epping_tx_timer_expire(epping_adapter_t *adapter);
void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue);
int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter);
int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *adapter);
#ifdef HIF_SDIO
enum htc_send_full_action epping_tx_queue_full(void *Context,
struct _HTC_PACKET *pPacket);
#endif
void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
void epping_tx_dup_pkt(epping_adapter_t *adapter,
HTC_ENDPOINT_ID eid, qdf_nbuf_t skb);
/* epping_rx signatures */
void epping_rx(void *Context, HTC_PACKET *pPacket);
@@ -187,7 +187,7 @@ void epping_refill(void *ctx, HTC_ENDPOINT_ID Endpoint);
epping_adapter_t *epping_add_adapter(epping_context_t *pEpping_ctx,
tSirMacAddr macAddr,
enum tQDF_ADAPTER_MODE device_mode);
void epping_destroy_adapter(epping_adapter_t *pAdapter);
void epping_destroy_adapter(epping_adapter_t *adapter);
int epping_connect_service(epping_context_t *pEpping_ctx);
#ifdef HIF_PCI
void epping_register_tx_copier(HTC_ENDPOINT_ID eid,

36
utils/epping/src/epping_helper.c
View File

@@ -168,7 +168,7 @@ void *epping_get_qdf_ctx(void)
return qdf_ctx;
}
void epping_log_packet(epping_adapter_t *pAdapter,
void epping_log_packet(epping_adapter_t *adapter,
EPPING_HEADER *eppingHdr, int ret, const char *str)
{
if (eppingHdr->Cmd_h & EPPING_LOG_MASK) {
@@ -178,33 +178,33 @@ void epping_log_packet(epping_adapter_t *pAdapter,
"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);
adapter->stats.tx_packets,
adapter->stats.tx_dropped,
adapter->stats.tx_bytes,
adapter->stats.rx_packets,
adapter->stats.rx_dropped,
adapter->stats.rx_bytes);
}
}
void epping_log_stats(epping_adapter_t *pAdapter, const char *str)
void epping_log_stats(epping_adapter_t *adapter, const char *str)
{
EPPING_LOG(QDF_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);
adapter->stats.tx_packets,
adapter->stats.tx_dropped,
adapter->stats.tx_bytes,
adapter->stats.rx_packets,
adapter->stats.rx_dropped,
adapter->stats.rx_bytes,
adapter->pEpping_ctx->total_tx_acks);
}
void epping_set_kperf_flag(epping_adapter_t *pAdapter,
void epping_set_kperf_flag(epping_adapter_t *adapter,
HTC_ENDPOINT_ID eid, A_UINT8 kperf_flag)
{
pAdapter->pEpping_ctx->kperf_num_rx_recv[eid] = 0;
pAdapter->pEpping_ctx->kperf_num_tx_acks[eid] = 0;
adapter->pEpping_ctx->kperf_num_rx_recv[eid] = 0;
adapter->pEpping_ctx->kperf_num_tx_acks[eid] = 0;
}

18
utils/epping/src/epping_rx.c
View File

@@ -110,15 +110,15 @@ void epping_refill(void *ctx, HTC_ENDPOINT_ID Endpoint)
void epping_rx(void *ctx, HTC_PACKET *pPacket)
{
epping_context_t *pEpping_ctx = (epping_context_t *) ctx;
epping_adapter_t *pAdapter = pEpping_ctx->epping_adapter;
struct net_device *dev = pAdapter->dev;
epping_adapter_t *adapter = pEpping_ctx->epping_adapter;
struct net_device *dev = adapter->dev;
QDF_STATUS status = pPacket->Status;
HTC_ENDPOINT_ID eid = pPacket->Endpoint;
struct sk_buff *pktSkb = (struct sk_buff *)pPacket->pPktContext;
EPPING_LOG(QDF_TRACE_LEVEL_INFO,
"%s: pAdapter = 0x%p eid=%d, skb=0x%p, data=0x%p, len=0x%x status:%d",
__func__, pAdapter, eid, pktSkb, pPacket->pBuffer,
"%s: adapter = 0x%p eid=%d, skb=0x%p, data=0x%p, len=0x%x status:%d",
__func__, adapter, eid, pktSkb, pPacket->pBuffer,
pPacket->ActualLength, status);
if (status != QDF_STATUS_SUCCESS) {
@@ -140,22 +140,22 @@ void epping_rx(void *ctx, HTC_PACKET *pPacket)
pktSkb->dev = dev;
if ((pktSkb->dev->flags & IFF_UP) == IFF_UP) {
pktSkb->protocol = eth_type_trans(pktSkb, pktSkb->dev);
++pAdapter->stats.rx_packets;
pAdapter->stats.rx_bytes += pktSkb->len;
++adapter->stats.rx_packets;
adapter->stats.rx_bytes += pktSkb->len;
qdf_net_buf_debug_release_skb(pktSkb);
if (hdd_napi_enabled(HDD_NAPI_ANY))
netif_receive_skb(pktSkb);
else
netif_rx_ni(pktSkb);
if ((pAdapter->stats.rx_packets %
if ((adapter->stats.rx_packets %
EPPING_STATS_LOG_COUNT) == 0) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: total_rx_pkts = %lu",
__func__,
pAdapter->stats.rx_packets);
adapter->stats.rx_packets);
}
} else {
++pAdapter->stats.rx_dropped;
++adapter->stats.rx_dropped;
qdf_nbuf_free(pktSkb);
}
}

118
utils/epping/src/epping_tx.c
View File

@@ -55,14 +55,14 @@
static bool enb_tx_dump;
void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
void epping_tx_dup_pkt(epping_adapter_t *adapter,
HTC_ENDPOINT_ID eid, qdf_nbuf_t skb)
{
struct epping_cookie *cookie = NULL;
int skb_len, ret;
qdf_nbuf_t new_skb;
cookie = epping_alloc_cookie(pAdapter->pEpping_ctx);
cookie = epping_alloc_cookie(adapter->pEpping_ctx);
if (cookie == NULL) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: epping_alloc_cookie returns no resource\n",
@@ -73,7 +73,7 @@ void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
if (!new_skb) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: qdf_nbuf_copy returns no resource\n", __func__);
epping_free_cookie(pAdapter->pEpping_ctx, cookie);
epping_free_cookie(adapter->pEpping_ctx, cookie);
return;
}
SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
@@ -82,24 +82,24 @@ void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
SET_HTC_PACKET_NET_BUF_CONTEXT(&cookie->HtcPkt, new_skb);
skb_len = (int)qdf_nbuf_len(new_skb);
/* send the packet */
ret = htc_send_pkt(pAdapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
ret = htc_send_pkt(adapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
if (ret != QDF_STATUS_SUCCESS) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: htc_send_pkt failed, ret = %d\n", __func__, ret);
epping_free_cookie(pAdapter->pEpping_ctx, cookie);
epping_free_cookie(adapter->pEpping_ctx, cookie);
qdf_nbuf_free(new_skb);
return;
}
pAdapter->stats.tx_bytes += skb_len;
++pAdapter->stats.tx_packets;
if (((pAdapter->stats.tx_packets +
pAdapter->stats.tx_dropped) % EPPING_STATS_LOG_COUNT) == 0 &&
(pAdapter->stats.tx_packets || pAdapter->stats.tx_dropped)) {
epping_log_stats(pAdapter, __func__);
adapter->stats.tx_bytes += skb_len;
++adapter->stats.tx_packets;
if (((adapter->stats.tx_packets +
adapter->stats.tx_dropped) % EPPING_STATS_LOG_COUNT) == 0 &&
(adapter->stats.tx_packets || adapter->stats.tx_dropped)) {
epping_log_stats(adapter, __func__);
}
}
static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *adapter)
{
EPPING_HEADER *eppingHdr = (EPPING_HEADER *) qdf_nbuf_data(skb);
HTC_ENDPOINT_ID eid = ENDPOINT_UNUSED;
@@ -110,7 +110,7 @@ static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
EPPING_HEADER tmpHdr = *eppingHdr;
/* allocate resource for this packet */
cookie = epping_alloc_cookie(pAdapter->pEpping_ctx);
cookie = epping_alloc_cookie(adapter->pEpping_ctx);
/* no resource */
if (cookie == NULL) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
@@ -131,7 +131,7 @@ static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
}
/* prepare ep/HTC information */
ac = eppingHdr->StreamNo_h;
eid = pAdapter->pEpping_ctx->EppingEndpoint[ac];
eid = adapter->pEpping_ctx->EppingEndpoint[ac];
if (eid < 0 || eid >= EPPING_MAX_NUM_EPIDS) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: invalid eid = %d, ac = %d\n", __func__, eid,
@@ -140,7 +140,7 @@ static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
}
if (tmpHdr.Cmd_h == EPPING_CMD_RESET_RECV_CNT ||
tmpHdr.Cmd_h == EPPING_CMD_CONT_RX_START) {
epping_set_kperf_flag(pAdapter, eid, tmpHdr.CmdBuffer_t[0]);
epping_set_kperf_flag(adapter, eid, tmpHdr.CmdBuffer_t[0]);
}
SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
cookie, qdf_nbuf_data(skb), qdf_nbuf_len(skb),
@@ -148,52 +148,52 @@ static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
SET_HTC_PACKET_NET_BUF_CONTEXT(&cookie->HtcPkt, skb);
skb_len = skb->len;
/* send the packet */
ret = htc_send_pkt(pAdapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
epping_log_packet(pAdapter, &tmpHdr, ret, __func__);
ret = htc_send_pkt(adapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
epping_log_packet(adapter, &tmpHdr, ret, __func__);
if (ret != QDF_STATUS_SUCCESS) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: htc_send_pkt failed, status = %d\n", __func__,
ret);
epping_free_cookie(pAdapter->pEpping_ctx, cookie);
epping_free_cookie(adapter->pEpping_ctx, cookie);
return A_ERROR;
}
pAdapter->stats.tx_bytes += skb_len;
++pAdapter->stats.tx_packets;
if (((pAdapter->stats.tx_packets +
pAdapter->stats.tx_dropped) % EPPING_STATS_LOG_COUNT) == 0 &&
(pAdapter->stats.tx_packets || pAdapter->stats.tx_dropped)) {
epping_log_stats(pAdapter, __func__);
adapter->stats.tx_bytes += skb_len;
++adapter->stats.tx_packets;
if (((adapter->stats.tx_packets +
adapter->stats.tx_dropped) % EPPING_STATS_LOG_COUNT) == 0 &&
(adapter->stats.tx_packets || adapter->stats.tx_dropped)) {
epping_log_stats(adapter, __func__);
}
return 0;
}
void epping_tx_timer_expire(epping_adapter_t *pAdapter)
void epping_tx_timer_expire(epping_adapter_t *adapter)
{
qdf_nbuf_t nodrop_skb;
EPPING_LOG(QDF_TRACE_LEVEL_INFO, "%s: queue len: %d\n", __func__,
qdf_nbuf_queue_len(&pAdapter->nodrop_queue));
qdf_nbuf_queue_len(&adapter->nodrop_queue));
if (!qdf_nbuf_queue_len(&pAdapter->nodrop_queue)) {
if (!qdf_nbuf_queue_len(&adapter->nodrop_queue)) {
/* nodrop queue is empty so no need to arm timer */
pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
return;
}
/* try to flush nodrop queue */
while ((nodrop_skb = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue))) {
htc_set_nodrop_pkt(pAdapter->pEpping_ctx->HTCHandle, true);
if (epping_tx_send_int(nodrop_skb, pAdapter)) {
while ((nodrop_skb = qdf_nbuf_queue_remove(&adapter->nodrop_queue))) {
htc_set_nodrop_pkt(adapter->pEpping_ctx->HTCHandle, true);
if (epping_tx_send_int(nodrop_skb, adapter)) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: nodrop: %p xmit fail in timer\n",
__func__, nodrop_skb);
/* fail to xmit so put the nodrop packet to the nodrop queue */
qdf_nbuf_queue_insert_head(&pAdapter->nodrop_queue,
qdf_nbuf_queue_insert_head(&adapter->nodrop_queue,
nodrop_skb);
break;
} else {
htc_set_nodrop_pkt(pAdapter->pEpping_ctx->HTCHandle, false);
htc_set_nodrop_pkt(adapter->pEpping_ctx->HTCHandle, false);
EPPING_LOG(QDF_TRACE_LEVEL_INFO,
"%s: nodrop: %p xmit ok in timer\n",
__func__, nodrop_skb);
@@ -202,20 +202,20 @@ void epping_tx_timer_expire(epping_adapter_t *pAdapter)
/* if nodrop queue is not empty, continue to arm timer */
if (nodrop_skb) {
qdf_spin_lock_bh(&pAdapter->data_lock);
qdf_spin_lock_bh(&adapter->data_lock);
/* if nodrop queue is not empty, continue to arm timer */
if (pAdapter->epping_timer_state != EPPING_TX_TIMER_RUNNING) {
pAdapter->epping_timer_state = EPPING_TX_TIMER_RUNNING;
qdf_timer_mod(&pAdapter->epping_timer,
if (adapter->epping_timer_state != EPPING_TX_TIMER_RUNNING) {
adapter->epping_timer_state = EPPING_TX_TIMER_RUNNING;
qdf_timer_mod(&adapter->epping_timer,
TX_RETRY_TIMEOUT_IN_MS);
}
qdf_spin_unlock_bh(&pAdapter->data_lock);
qdf_spin_unlock_bh(&adapter->data_lock);
} else {
pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
}
}
int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *adapter)
{
qdf_nbuf_t nodrop_skb;
EPPING_HEADER *eppingHdr;
@@ -254,19 +254,19 @@ int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
*/
/* check the nodrop queue first */
while ((nodrop_skb = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue))) {
htc_set_nodrop_pkt(pAdapter->pEpping_ctx->HTCHandle, true);
if (epping_tx_send_int(nodrop_skb, pAdapter)) {
while ((nodrop_skb = qdf_nbuf_queue_remove(&adapter->nodrop_queue))) {
htc_set_nodrop_pkt(adapter->pEpping_ctx->HTCHandle, true);
if (epping_tx_send_int(nodrop_skb, adapter)) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: nodrop: %p xmit fail\n", __func__,
nodrop_skb);
/* fail to xmit so put the nodrop packet to the nodrop queue */
qdf_nbuf_queue_insert_head(&pAdapter->nodrop_queue,
qdf_nbuf_queue_insert_head(&adapter->nodrop_queue,
nodrop_skb);
/* no cookie so free the current skb */
goto tx_fail;
} else {
htc_set_nodrop_pkt(pAdapter->pEpping_ctx->HTCHandle, false);
htc_set_nodrop_pkt(adapter->pEpping_ctx->HTCHandle, false);
EPPING_LOG(QDF_TRACE_LEVEL_INFO,
"%s: nodrop: %p xmit ok\n", __func__,
nodrop_skb);
@@ -274,7 +274,7 @@ int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
}
/* send the original packet */
if (epping_tx_send_int(skb, pAdapter))
if (epping_tx_send_int(skb, adapter))
goto tx_fail;
return 0;
@@ -283,22 +283,22 @@ tx_fail:
if (!IS_EPING_PACKET_NO_DROP(eppingHdr)) {
/* allow to drop the skb so drop it */
qdf_nbuf_free(skb);
++pAdapter->stats.tx_dropped;
++adapter->stats.tx_dropped;
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: Tx skb %p dropped, stats.tx_dropped = %ld\n",
__func__, skb, pAdapter->stats.tx_dropped);
__func__, skb, adapter->stats.tx_dropped);
return -ENOMEM;
} else {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: nodrop: %p queued\n", __func__, skb);
qdf_nbuf_queue_add(&pAdapter->nodrop_queue, skb);
qdf_spin_lock_bh(&pAdapter->data_lock);
if (pAdapter->epping_timer_state != EPPING_TX_TIMER_RUNNING) {
pAdapter->epping_timer_state = EPPING_TX_TIMER_RUNNING;
qdf_timer_mod(&pAdapter->epping_timer,
qdf_nbuf_queue_add(&adapter->nodrop_queue, skb);
qdf_spin_lock_bh(&adapter->data_lock);
if (adapter->epping_timer_state != EPPING_TX_TIMER_RUNNING) {
adapter->epping_timer_state = EPPING_TX_TIMER_RUNNING;
qdf_timer_mod(&adapter->epping_timer,
TX_RETRY_TIMEOUT_IN_MS);
}
qdf_spin_unlock_bh(&pAdapter->data_lock);
qdf_spin_unlock_bh(&adapter->data_lock);
}
return 0;
@@ -318,8 +318,8 @@ enum htc_send_full_action epping_tx_queue_full(void *Context,
void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
{
epping_context_t *pEpping_ctx = (epping_context_t *) ctx;
epping_adapter_t *pAdapter = pEpping_ctx->epping_adapter;
struct net_device *dev = pAdapter->dev;
epping_adapter_t *adapter = pEpping_ctx->epping_adapter;
struct net_device *dev = adapter->dev;
QDF_STATUS status;
HTC_ENDPOINT_ID eid;
qdf_nbuf_t pktSkb;
@@ -330,7 +330,7 @@ void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
qdf_nbuf_queue_init(&skb_queue);
qdf_spin_lock_bh(&pAdapter->data_lock);
qdf_spin_lock_bh(&adapter->data_lock);
while (!HTC_QUEUE_EMPTY(pPacketQueue)) {
htc_pkt = htc_packet_dequeue(pPacketQueue);
@@ -385,10 +385,10 @@ void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
flushing = false;
}
epping_free_cookie(pAdapter->pEpping_ctx, cookie);
epping_free_cookie(adapter->pEpping_ctx, cookie);
}
qdf_spin_unlock_bh(&pAdapter->data_lock);
qdf_spin_unlock_bh(&adapter->data_lock);
/* free all skbs in our local list */
while (qdf_nbuf_queue_len(&skb_queue)) {

176
utils/epping/src/epping_txrx.c
View File

@@ -51,13 +51,13 @@
#include "epping_main.h"
#include "epping_internal.h"
static int epping_start_adapter(epping_adapter_t *pAdapter);
static void epping_stop_adapter(epping_adapter_t *pAdapter);
static int epping_start_adapter(epping_adapter_t *adapter);
static void epping_stop_adapter(epping_adapter_t *adapter);
static void epping_timer_expire(void *data)
{
struct net_device *dev = (struct net_device *)data;
epping_adapter_t *pAdapter;
epping_adapter_t *adapter;
if (dev == NULL) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
@@ -65,79 +65,79 @@ static void epping_timer_expire(void *data)
return;
}
pAdapter = netdev_priv(dev);
if (pAdapter == NULL) {
adapter = netdev_priv(dev);
if (adapter == NULL) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: adapter = NULL", __func__);
return;
}
pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
epping_tx_timer_expire(pAdapter);
adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
epping_tx_timer_expire(adapter);
}
static int epping_ndev_open(struct net_device *dev)
{
epping_adapter_t *pAdapter;
epping_adapter_t *adapter;
int ret = 0;
pAdapter = netdev_priv(dev);
epping_start_adapter(pAdapter);
adapter = netdev_priv(dev);
epping_start_adapter(adapter);
return ret;
}
static int epping_ndev_stop(struct net_device *dev)
{
epping_adapter_t *pAdapter;
epping_adapter_t *adapter;
int ret = 0;
pAdapter = netdev_priv(dev);
if (NULL == pAdapter) {
adapter = netdev_priv(dev);
if (NULL == adapter) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: EPPING adapter context is Null", __func__);
ret = -ENODEV;
goto end;
}
epping_stop_adapter(pAdapter);
epping_stop_adapter(adapter);
end:
return ret;
}
static void epping_ndev_uninit(struct net_device *dev)
{
epping_adapter_t *pAdapter;
epping_adapter_t *adapter;
pAdapter = netdev_priv(dev);
if (NULL == pAdapter) {
adapter = netdev_priv(dev);
if (NULL == adapter) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: EPPING adapter context is Null", __func__);
goto end;
}
epping_stop_adapter(pAdapter);
epping_stop_adapter(adapter);
end:
return;
}
static void epping_tx_queue_timeout(struct net_device *dev)
{
epping_adapter_t *pAdapter;
epping_adapter_t *adapter;
pAdapter = netdev_priv(dev);
if (NULL == pAdapter) {
adapter = netdev_priv(dev);
if (NULL == adapter) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: EPPING adapter context is Null", __func__);
goto end;
}
EPPING_LOG(QDF_TRACE_LEVEL_ERROR,
"%s: Transmission timeout occurred, pAdapter->started= %d",
__func__, pAdapter->started);
"%s: Transmission timeout occurred, adapter->started= %d",
__func__, adapter->started);
/* Getting here implies we disabled the TX queues
* for too long. Since this is epping
* (not because of disassociation or low resource scenarios),
* try to restart the queue
*/
if (pAdapter->started)
if (adapter->started)
netif_wake_queue(dev);
end:
return;
@@ -146,47 +146,47 @@ end:
static int epping_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
epping_adapter_t *pAdapter;
epping_adapter_t *adapter;
int ret = 0;
pAdapter = netdev_priv(dev);
if (NULL == pAdapter) {
adapter = netdev_priv(dev);
if (NULL == adapter) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: EPPING adapter context is Null", __func__);
ret = -ENODEV;
goto end;
}
ret = epping_tx_send(skb, pAdapter);
ret = epping_tx_send(skb, adapter);
end:
return ret;
}
static struct net_device_stats *epping_get_stats(struct net_device *dev)
{
epping_adapter_t *pAdapter = netdev_priv(dev);
epping_adapter_t *adapter = netdev_priv(dev);
if (NULL == pAdapter) {
EPPING_LOG(QDF_TRACE_LEVEL_ERROR, "%s: pAdapter = NULL",
if (NULL == adapter) {
EPPING_LOG(QDF_TRACE_LEVEL_ERROR, "%s: adapter = NULL",
__func__);
return NULL;
}
return &pAdapter->stats;
return &adapter->stats;
}
static int epping_ndev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
epping_adapter_t *pAdapter;
epping_adapter_t *adapter;
int ret = 0;
pAdapter = netdev_priv(dev);
if (NULL == pAdapter) {
adapter = netdev_priv(dev);
if (NULL == adapter) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: EPPING adapter context is Null", __func__);
ret = -ENODEV;
goto end;
}
if (dev != pAdapter->dev) {
if (dev != adapter->dev) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: HDD adapter/dev inconsistency", __func__);
ret = -ENODEV;
@@ -217,15 +217,15 @@ end:
static int epping_set_mac_address(struct net_device *dev, void *addr)
{
epping_adapter_t *pAdapter = netdev_priv(dev);
epping_adapter_t *adapter = netdev_priv(dev);
struct sockaddr *psta_mac_addr = addr;
qdf_mem_copy(&pAdapter->macAddressCurrent,
qdf_mem_copy(&adapter->macAddressCurrent,
psta_mac_addr->sa_data, ETH_ALEN);
qdf_mem_copy(dev->dev_addr, psta_mac_addr->sa_data, ETH_ALEN);
return 0;
}
static void epping_stop_adapter(epping_adapter_t *pAdapter)
static void epping_stop_adapter(epping_adapter_t *adapter)
{
qdf_device_t qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
@@ -235,17 +235,17 @@ static void epping_stop_adapter(epping_adapter_t *pAdapter)
return;
}
if (pAdapter && pAdapter->started) {
if (adapter && adapter->started) {
EPPING_LOG(LOG1, FL("Disabling queues"));
netif_tx_disable(pAdapter->dev);
netif_carrier_off(pAdapter->dev);
pAdapter->started = false;
netif_tx_disable(adapter->dev);
netif_carrier_off(adapter->dev);
adapter->started = false;
pld_request_bus_bandwidth(qdf_ctx->dev,
PLD_BUS_WIDTH_LOW);
}
}
static int epping_start_adapter(epping_adapter_t *pAdapter)
static int epping_start_adapter(epping_adapter_t *adapter)
{
qdf_device_t qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
@@ -255,78 +255,78 @@ static int epping_start_adapter(epping_adapter_t *pAdapter)
return -EINVAL;
}
if (!pAdapter) {
if (!adapter) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: pAdapter= NULL\n", __func__);
"%s: adapter= NULL\n", __func__);
return -EINVAL;
}
if (!pAdapter->started) {
if (!adapter->started) {
pld_request_bus_bandwidth(qdf_ctx->dev,
PLD_BUS_WIDTH_HIGH);
netif_carrier_on(pAdapter->dev);
netif_carrier_on(adapter->dev);
EPPING_LOG(LOG1, FL("Enabling queues"));
netif_tx_start_all_queues(pAdapter->dev);
pAdapter->started = true;
netif_tx_start_all_queues(adapter->dev);
adapter->started = true;
} else {
EPPING_LOG(QDF_TRACE_LEVEL_WARN,
"%s: pAdapter %p already started\n", __func__,
pAdapter);
"%s: adapter %p already started\n", __func__,
adapter);
}
return 0;
}
static int epping_register_adapter(epping_adapter_t *pAdapter)
static int epping_register_adapter(epping_adapter_t *adapter)
{
int ret = 0;
ret = register_netdev(pAdapter->dev);
ret = register_netdev(adapter->dev);
if (ret != 0) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: unable to register device\n",
pAdapter->dev->name);
adapter->dev->name);
} else {
pAdapter->registered = true;
adapter->registered = true;
}
return ret;
}
static void epping_unregister_adapter(epping_adapter_t *pAdapter)
static void epping_unregister_adapter(epping_adapter_t *adapter)
{
if (pAdapter) {
epping_stop_adapter(pAdapter);
if (pAdapter->registered) {
unregister_netdev(pAdapter->dev);
pAdapter->registered = false;
if (adapter) {
epping_stop_adapter(adapter);
if (adapter->registered) {
unregister_netdev(adapter->dev);
adapter->registered = false;
}
} else {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: pAdapter = NULL, unable to unregister device\n",
"%s: adapter = NULL, unable to unregister device\n",
__func__);
}
}
void epping_destroy_adapter(epping_adapter_t *pAdapter)
void epping_destroy_adapter(epping_adapter_t *adapter)
{
struct net_device *dev = NULL;
epping_context_t *pEpping_ctx;
if (!pAdapter || !pAdapter->pEpping_ctx) {
if (!adapter || !adapter->pEpping_ctx) {
EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
"%s: pAdapter = NULL\n", __func__);
"%s: adapter = NULL\n", __func__);
return;
}
dev = pAdapter->dev;
pEpping_ctx = pAdapter->pEpping_ctx;
epping_unregister_adapter(pAdapter);
dev = adapter->dev;
pEpping_ctx = adapter->pEpping_ctx;
epping_unregister_adapter(adapter);
qdf_spinlock_destroy(&pAdapter->data_lock);
qdf_timer_free(&pAdapter->epping_timer);
pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
qdf_spinlock_destroy(&adapter->data_lock);
qdf_timer_free(&adapter->epping_timer);
adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
while (qdf_nbuf_queue_len(&pAdapter->nodrop_queue)) {
while (qdf_nbuf_queue_len(&adapter->nodrop_queue)) {
qdf_nbuf_t tmp_nbuf = NULL;
tmp_nbuf = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue);
tmp_nbuf = qdf_nbuf_queue_remove(&adapter->nodrop_queue);
if (tmp_nbuf)
qdf_nbuf_free(tmp_nbuf);
}
@@ -358,7 +358,7 @@ epping_adapter_t *epping_add_adapter(epping_context_t *pEpping_ctx,
enum tQDF_ADAPTER_MODE device_mode)
{
struct net_device *dev;
epping_adapter_t *pAdapter;
epping_adapter_t *adapter;
dev = alloc_netdev(sizeof(epping_adapter_t), "wifi%d",
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0))
@@ -371,30 +371,30 @@ epping_adapter_t *epping_add_adapter(epping_context_t *pEpping_ctx,
return NULL;
}
pAdapter = netdev_priv(dev);
qdf_mem_zero(pAdapter, sizeof(*pAdapter));
pAdapter->dev = dev;
pAdapter->pEpping_ctx = pEpping_ctx;
pAdapter->device_mode = device_mode; /* station, SAP, etc */
adapter = netdev_priv(dev);
qdf_mem_zero(adapter, sizeof(*adapter));
adapter->dev = dev;
adapter->pEpping_ctx = pEpping_ctx;
adapter->device_mode = device_mode; /* station, SAP, etc */
qdf_mem_copy(dev->dev_addr, (void *)macAddr, sizeof(tSirMacAddr));
qdf_mem_copy(pAdapter->macAddressCurrent.bytes,
qdf_mem_copy(adapter->macAddressCurrent.bytes,
macAddr, sizeof(tSirMacAddr));
qdf_spinlock_create(&pAdapter->data_lock);
qdf_nbuf_queue_init(&pAdapter->nodrop_queue);
pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
qdf_timer_init(epping_get_qdf_ctx(), &pAdapter->epping_timer,
qdf_spinlock_create(&adapter->data_lock);
qdf_nbuf_queue_init(&adapter->nodrop_queue);
adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
qdf_timer_init(epping_get_qdf_ctx(), &adapter->epping_timer,
epping_timer_expire, dev, QDF_TIMER_TYPE_SW);
dev->type = ARPHRD_IEEE80211;
dev->netdev_ops = &epping_drv_ops;
dev->watchdog_timeo = 5 * HZ; /* XXX */
dev->tx_queue_len = EPPING_TXBUF - 1; /* 1 for mgmt frame */
if (epping_register_adapter(pAdapter) == 0) {
if (epping_register_adapter(adapter) == 0) {
EPPING_LOG(LOG1, FL("Disabling queues"));
netif_tx_disable(dev);
netif_carrier_off(dev);
return pAdapter;
return adapter;
} else {
epping_destroy_adapter(pAdapter);
epping_destroy_adapter(adapter);
return NULL;
}
}