/*
|
* Copyright (C) 2016 Spreadtrum Communications Inc.
|
*
|
* Authors :
|
* star.liu <star.liu@spreadtrum.com>
|
* yifei.li <yifei.li@spreadtrum.com>
|
*
|
* This software is licensed under the terms of the GNU General Public
|
* License version 2, as published by the Free Software Foundation, and
|
* may be copied, distributed, and modified under those terms.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*/
|
|
#include "rx_msg.h"
|
#include "wl_core.h"
|
#include "msg.h"
|
#include "sprdwl.h"
|
#include "txrx.h"
|
#include "intf.h"
|
#include "wl_intf.h"
|
#include "tx_msg.h"
|
#include <net/ip6_checksum.h>
|
#include "debug.h"
|
#include "tcp_ack.h"
|
|
#ifdef RX_HW_CSUM
|
bool mh_ipv6_ext_hdr(unsigned char nexthdr)
|
{
|
return (nexthdr == NEXTHDR_HOP) ||
|
(nexthdr == NEXTHDR_ROUTING) ||
|
(nexthdr == NEXTHDR_DEST);
|
}
|
|
int ipv6_csum(void *data, __wsum csum)
|
{
|
int ret = 0;
|
struct rx_msdu_desc *msdu_desc = (struct rx_msdu_desc *)data;
|
struct ethhdr *eth = (struct ethhdr *)(data + msdu_desc->msdu_offset);
|
struct ipv6hdr *ip6h = NULL;
|
struct ipv6_opt_hdr *hp = NULL;
|
unsigned short dataoff = ETH_HLEN;
|
unsigned short nexthdr = 0;
|
|
wl_debug("%s: eth_type: 0x%x\n", __func__, eth->h_proto);
|
|
if (eth->h_proto == cpu_to_be16(ETH_P_IPV6)) {
|
data += msdu_desc->msdu_offset;
|
ip6h = data + dataoff;
|
nexthdr = ip6h->nexthdr;
|
dataoff += sizeof(*ip6h);
|
|
while (mh_ipv6_ext_hdr(nexthdr)) {
|
wl_debug("%s: nexthdr: %d\n", __func__, nexthdr);
|
hp = (struct ipv6_opt_hdr *)(data + dataoff);
|
dataoff += ipv6_optlen(hp);
|
nexthdr = hp->nexthdr;
|
}
|
|
wl_debug("%s: nexthdr: %d, dataoff: %d, len: %d\n",
|
__func__, nexthdr, dataoff,
|
(msdu_desc->msdu_len - dataoff));
|
|
if (!csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
|
(msdu_desc->msdu_len - dataoff),
|
nexthdr, csum)) {
|
ret = 1;
|
} else {
|
ret = -1;
|
}
|
|
wl_debug("%s: ret: %d\n", __func__, ret);
|
}
|
|
return ret;
|
}
|
|
unsigned short get_sdio_data_csum(void *entry, void *data)
|
{
|
unsigned short csum = 0;
|
struct sdiohal_puh *puh = (struct sdiohal_puh *)data;
|
struct rx_msdu_desc *msdu_desc =
|
(struct rx_msdu_desc *)(data + sizeof(*puh));
|
unsigned int csum_offset = msdu_total_len(msdu_desc) + sizeof(*puh);
|
struct sprdwl_intf *intf = (struct sprdwl_intf *)entry;
|
|
wl_debug("%s: check_sum: %d\n", __func__, puh->check_sum);
|
if ((intf->priv->hw_type == SPRDWL_HW_SDIO) && puh->check_sum) {
|
memcpy(&csum, (void *)(data + csum_offset), sizeof(csum));
|
wl_debug("%s: csum: 0x%x\n", __func__, csum);
|
}
|
|
return csum;
|
}
|
|
unsigned short get_pcie_data_csum(void *entry, void *data)
|
{
|
unsigned short csum = 0;
|
struct rx_mh_desc *mh_desc = (struct rx_mh_desc *)data;
|
struct sprdwl_intf *intf = (struct sprdwl_intf *)entry;
|
|
if (intf->priv->hw_type == SPRDWL_HW_PCIE) {
|
if (mh_desc->tcp_checksum_en)
|
csum = mh_desc->tcp_hw_checksum;
|
}
|
|
return csum;
|
}
|
|
inline int fill_skb_csum(struct sk_buff *skb, unsigned short csum)
|
{
|
int ret = 0;
|
|
if (csum) {
|
ret = ipv6_csum(skb->data, (__force __wsum)csum);
|
if (!ret) {
|
skb->ip_summed = CHECKSUM_COMPLETE;
|
skb->csum = (__force __wsum)csum;
|
} else if (ret > 0) {
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
}
|
} else {
|
skb->ip_summed = CHECKSUM_NONE;
|
}
|
|
return ret;
|
}
|
#endif
|
|
void sprdwl_rx_send_cmd(struct sprdwl_intf *intf, void *data, int len,
|
unsigned char id, unsigned char ctx_id)
|
{
|
struct sprdwl_priv *priv = intf->priv;
|
|
sprdwl_rx_send_cmd_process(priv, data, len, id, ctx_id);
|
}
|
|
void sprdwl_rx_process(struct sprdwl_rx_if *rx_if, struct sk_buff *pskb)
|
{
|
#ifndef SPLIT_STACK
|
struct sprdwl_priv *priv = rx_if->intf->priv;
|
struct sk_buff *reorder_skb = NULL, *skb = NULL;
|
#endif
|
|
/* TODO: Add rx mh data process */
|
#ifdef SPLIT_STACK
|
reorder_data_process(&rx_if->ba_entry, pskb);
|
|
if (!work_pending(&rx_if->rx_net_work))
|
queue_work(rx_if->rx_net_workq, &rx_if->rx_net_work);
|
#else
|
reorder_skb = reorder_data_process(&rx_if->ba_entry, pskb);
|
|
while (reorder_skb) {
|
SPRDWL_GET_FIRST_SKB(skb, reorder_skb);
|
skb = defrag_data_process(&rx_if->defrag_entry, skb);
|
if (skb)
|
sprdwl_rx_skb_process(priv, skb);
|
}
|
#endif
|
}
|
|
static inline void
|
sprdwl_rx_mh_data_process(struct sprdwl_rx_if *rx_if, void *data,
|
int len, int buffer_type)
|
{
|
mm_mh_data_process(&rx_if->mm_entry, data, len, buffer_type);
|
}
|
|
static void
|
sprdwl_rx_mh_addr_process(struct sprdwl_rx_if *rx_if, void *data,
|
int len, int buffer_type)
|
{
|
struct sprdwl_intf *intf = rx_if->intf;
|
struct sprdwl_common_hdr *hdr =
|
(struct sprdwl_common_hdr *)(data + intf->hif_offset);
|
|
if (hdr->reserv) {
|
mm_mh_data_event_process(&rx_if->mm_entry, data,
|
len, buffer_type);
|
} else {
|
/* TODO: Add TX complete code here */
|
sprdwl_tx_free_pcie_data(intf, (unsigned char *)data, len);
|
wl_err("%s: Add TX complete code here\n", __func__);
|
}
|
}
|
|
#ifdef SPLIT_STACK
|
void sprdwl_rx_net_work_queue(struct work_struct *work)
|
{
|
struct sprdwl_rx_if *rx_if;
|
struct sprdwl_priv *priv;
|
struct sk_buff *reorder_skb = NULL, *skb = NULL;
|
|
rx_if = container_of(work, struct sprdwl_rx_if, rx_net_work);
|
priv = rx_if->intf->priv;
|
|
reorder_skb = reorder_get_skb_list(&rx_if->ba_entry);
|
while (reorder_skb) {
|
SPRDWL_GET_FIRST_SKB(skb, reorder_skb);
|
skb = defrag_data_process(&rx_if->defrag_entry, skb);
|
if (skb)
|
sprdwl_rx_skb_process(priv, skb);
|
}
|
}
|
#endif
|
|
static void sprdwl_rx_work_queue(struct work_struct *work)
|
{
|
struct sprdwl_msg_buf *msg;
|
struct sprdwl_priv *priv;
|
struct sprdwl_rx_if *rx_if;
|
struct sprdwl_intf *intf;
|
void *pos = NULL, *data = NULL, *tran_data = NULL;
|
int len = 0, num = 0;
|
/*struct sprdwl_vif *vif;
|
struct sprdwl_cmd_hdr *hdr;*/
|
|
rx_if = container_of(work, struct sprdwl_rx_if, rx_work);
|
intf = rx_if->intf;
|
priv = intf->priv;
|
|
#ifndef RX_NAPI
|
if (!intf->exit && !sprdwl_peek_msg_buf(&rx_if->rx_list))
|
sprdwl_rx_process(rx_if, NULL);
|
#endif
|
|
while ((msg = sprdwl_peek_msg_buf(&rx_if->rx_list))) {
|
if (intf->exit)
|
goto next;
|
|
pos = msg->tran_data;
|
for (num = msg->len; num > 0; num--) {
|
pos = sprdwl_get_rx_data(intf, pos, &data, &tran_data,
|
&len, intf->hif_offset);
|
|
wl_debug("%s: rx type:%d, num = %d\n",
|
__func__, SPRDWL_HEAD_GET_TYPE(data), num);
|
|
/* len in mbuf_t just means buffer len in ADMA,
|
* so need to get data len in sdiohal_puh
|
*/
|
if (sprdwl_debug_level >= L_DBG) {
|
int print_len =
|
((struct sdiohal_puh *)tran_data)->len;
|
|
if (print_len > 100)
|
print_len = 100;
|
sprdwl_hex_dump("rx data",
|
(unsigned char *)data,
|
print_len);
|
}
|
#if 0
|
/* to check is the rsp_cnt from CP2
|
* eqaul to rsp_cnt count on driver side.
|
* if not equal, must be lost on SDIOHAL/PCIE.
|
* assert to warn CP2
|
*/
|
hdr = (struct sprdwl_cmd_hdr *)data;
|
vif = ctx_id_to_vif(priv, hdr->common.ctx_id);
|
if ((SPRDWL_HEAD_GET_TYPE(data) == SPRDWL_TYPE_CMD ||
|
SPRDWL_HEAD_GET_TYPE(data) == SPRDWL_TYPE_EVENT)) {
|
if (rx_if->rsp_event_cnt != hdr->rsp_cnt) {
|
wl_info("%s, %d, rsp_event_cnt=%d, hdr->cnt=%d\n",
|
__func__, __LINE__,
|
rx_if->rsp_event_cnt, hdr->rsp_cnt);
|
|
if (hdr->rsp_cnt == 0) {
|
rx_if->rsp_event_cnt = 0;
|
wl_info("%s reset rsp_event_cnt", __func__);
|
}
|
/* hdr->rsp_cnt=0 means it's a old version CP2,
|
* so do not assert.
|
* vif=NULL means driver not init ok,
|
* send cmd may cause crash
|
*/
|
if (vif != NULL && hdr->rsp_cnt != 0) {
|
wl_err("cmd_id:%d resp count = %d error\n",
|
hdr->cmd_id, hdr->rsp_cnt);
|
sprdwl_send_assert_cmd(vif, hdr->cmd_id, RSP_CNT_ERROR);
|
}
|
}
|
|
rx_if->rsp_event_cnt++;
|
}
|
sprdwl_put_vif(vif);
|
#endif
|
if (unlikely(priv->wakeup_tracer.resume_flag))
|
trace_rx_wakeup(&priv->wakeup_tracer, data,
|
tran_data + intf->hif_offset);
|
|
switch (SPRDWL_HEAD_GET_TYPE(data)) {
|
case SPRDWL_TYPE_DATA:
|
#if defined FPGA_LOOPBACK_TEST
|
if (intf->loopback_n < 500) {
|
unsigned char *r_buf;
|
|
r_buf = (unsigned char *)data;
|
sprdwl_intf_tx_data_fpga_test(intf,
|
r_buf,
|
len);
|
}
|
#else
|
if (msg->len > SPRDWL_MAX_DATA_RXLEN)
|
wl_err("err rx data too long:%d > %d\n",
|
len, SPRDWL_MAX_DATA_RXLEN);
|
sprdwl_rx_data_process(priv, data);
|
#endif /* FPGA_LOOPBACK_TEST */
|
break;
|
case SPRDWL_TYPE_CMD:
|
if (msg->len > SPRDWL_MAX_CMD_RXLEN)
|
wl_err("err rx cmd too long:%d > %d\n",
|
len, SPRDWL_MAX_CMD_RXLEN);
|
sprdwl_rx_rsp_process(priv, data);
|
break;
|
case SPRDWL_TYPE_PKT_LOG:
|
if (sprdwl_pkt_log_save(intf, data) == 1)
|
wl_err("%s: pkt log file open or create failed!\n",
|
__func__);
|
break;
|
case SPRDWL_TYPE_EVENT:
|
if (msg->len > SPRDWL_MAX_CMD_RXLEN)
|
wl_err("err rx event too long:%d > %d\n",
|
len, SPRDWL_MAX_CMD_RXLEN);
|
sprdwl_rx_event_process(priv, data);
|
break;
|
case SPRDWL_TYPE_DATA_SPECIAL:
|
debug_ts_leave(RX_SDIO_PORT);
|
debug_ts_enter(RX_SDIO_PORT);
|
|
if (msg->len > SPRDWL_MAX_DATA_RXLEN)
|
wl_err("err data trans too long:%d > %d\n",
|
len, SPRDWL_MAX_CMD_RXLEN);
|
sprdwl_rx_mh_data_process(rx_if, tran_data, len,
|
msg->buffer_type);
|
tran_data = NULL;
|
data = NULL;
|
break;
|
case SPRDWL_TYPE_DATA_PCIE_ADDR:
|
if (intf->priv->hw_type != SPRDWL_HW_PCIE) {
|
wl_err("error get pcie addr data!\n");
|
break;
|
}
|
if (msg->len > SPRDWL_MAX_CMD_RXLEN)
|
wl_err("err rx mh data too long:%d > %d\n",
|
len, SPRDWL_MAX_DATA_RXLEN);
|
sprdwl_rx_mh_addr_process(rx_if, tran_data, len,
|
msg->buffer_type);
|
tran_data = NULL;
|
data = NULL;
|
break;
|
default:
|
wl_err("rx unknown type:%d\n",
|
SPRDWL_HEAD_GET_TYPE(data));
|
break;
|
}
|
|
/* Marlin3 should release buffer by ourself */
|
if (tran_data)
|
sprdwl_free_data(tran_data, msg->buffer_type);
|
|
if (!pos) {
|
wl_debug("%s no mbuf\n", __func__);
|
break;
|
}
|
}
|
next:
|
/* TODO: Should we free mbuf one by one? */
|
sprdwl_free_rx_data(intf, msg->fifo_id, msg->tran_data,
|
msg->data, msg->len);
|
sprdwl_dequeue_msg_buf(msg, &rx_if->rx_list);
|
}
|
}
|
|
/*
|
* data_len:length of data recv by driver once time
|
* pkt_len:length of one type of packet in data
|
* pkt_line_num:line num in pkt log file
|
*/
|
int sprdwl_pkt_log_save(struct sprdwl_intf *intf, void *data)
|
{
|
int i, j, temp, data_len, pkt_line_num,
|
temp_pkt_line_num, pkt_len, m = 0;
|
#ifdef setfs
|
mm_segment_t fs;
|
#endif
|
/*for pkt log space key and enter key*/
|
char temp_space, temp_enter;
|
/*for pkt log txt line number and write pkt log into file*/
|
char temphdr[6], tempdata[3];
|
|
intf->pfile = filp_open(
|
"storage/sdcard0/Download/sprdwl_pkt_log.txt",
|
O_CREAT | O_RDWR, 0);
|
if (IS_ERR(intf->pfile)) {
|
wl_err("file create/open fail %s, %d\n", __func__, __LINE__);
|
return 1;
|
}
|
#ifdef setfs
|
fs = get_fs();
|
set_fs(KERNEL_DS);
|
#endif
|
pkt_len = ((struct sprdwl_pktlog_hdr *)(data))->plen;
|
data += sizeof(struct sprdwl_pktlog_hdr);
|
while (m < pkt_len) {
|
data_len = *((unsigned char *)(data + 2)) + 4;
|
m += data_len;
|
temp_space = ' ';
|
temp_enter = '\n';
|
temp_pkt_line_num = 0;
|
pkt_line_num = 0;
|
for (j = 0; j < 6; j++) {
|
temphdr[j] = '0';
|
}
|
kernel_write(intf->pfile, temphdr, 6, &intf->lp);
|
kernel_write(intf->pfile, &temp_space, 1, &intf->lp);
|
memset(tempdata, 0x00, 2);
|
for (i = 0; i < data_len; i++) {
|
sprintf(tempdata, "%02x",
|
*(unsigned char *)data);
|
kernel_write(intf->pfile, tempdata,
|
2, &intf->lp);
|
memset(tempdata, 0x00, 2);
|
if ((i != 0) && ((i + 1)%16 == 0)) {
|
if (i < (data_len - 1)) {
|
kernel_write(intf->pfile, &temp_enter,
|
sizeof(temp_enter), &intf->lp);
|
pkt_line_num += 16;
|
temp_pkt_line_num = pkt_line_num;
|
for (j = 0; j < 6; j++) {
|
temp = (temp_pkt_line_num >> (j*4)) & 0xf;
|
temphdr[5 - j] = (temp < 10) ? (temp + '0') : (temp - 10 + 'a');
|
}
|
kernel_write(intf->pfile, temphdr,
|
6, &intf->lp);
|
kernel_write(intf->pfile, &temp_space,
|
1, &intf->lp);
|
}
|
} else {
|
kernel_write(intf->pfile, &temp_space,
|
sizeof(temp_space), &intf->lp);
|
}
|
data++;
|
}
|
kernel_write(intf->pfile, &temp_enter, sizeof(temp_enter), &intf->lp);
|
memset(temphdr, 0x00, 6);
|
}
|
filp_close(intf->pfile, NULL);
|
#ifdef setfs
|
set_fs(fs);
|
#endif
|
return 0;
|
}
|
|
#ifdef RX_NAPI
|
static int sprdwl_netdev_poll_rx(struct napi_struct *napi, int budget)
|
{
|
struct sprdwl_msg_buf *msg;
|
struct sprdwl_priv *priv;
|
struct sprdwl_rx_if *rx_if;
|
struct sprdwl_intf *intf;
|
void *pos = NULL, *data = NULL, *tran_data = NULL;
|
int len = 0, num = 0;
|
int print_len;
|
|
int quota = budget;
|
int done;
|
|
rx_if = container_of(napi, struct sprdwl_rx_if, napi_rx);
|
intf = rx_if->intf;
|
priv = intf->priv;
|
|
if (!intf->exit && !sprdwl_peek_msg_buf(&rx_if->rx_data_list))
|
sprdwl_rx_process(rx_if, NULL);
|
|
while (quota && (msg = sprdwl_peek_msg_buf(&rx_if->rx_data_list))) {
|
if (intf->exit)
|
goto next;
|
|
pos = msg->tran_data;
|
for (num = msg->len; num > 0; num--) {
|
pos = sprdwl_get_rx_data(intf, pos, &data, &tran_data,
|
&len, intf->hif_offset);
|
|
wl_info("%s: rx type:%d\n",
|
__func__, SPRDWL_HEAD_GET_TYPE(data));
|
|
/* len in mbuf_t just means buffer len in ADMA,
|
* so need to get data len in sdiohal_puh
|
*/
|
if (((struct sdiohal_puh *)tran_data)->len > 100)
|
print_len = 100;
|
else
|
print_len = ((struct sdiohal_puh *)
|
tran_data)->len;
|
sprdwl_hex_dump("rx data",
|
(unsigned char *)data, print_len);
|
|
if (sprdwl_sdio_process_credit(intf, data))
|
goto free;
|
|
switch (SPRDWL_HEAD_GET_TYPE(data)) {
|
case SPRDWL_TYPE_DATA_SPECIAL:
|
if (msg->len > SPRDWL_MAX_DATA_RXLEN)
|
wl_err("err data trans too long:%d > %d\n",
|
len, SPRDWL_MAX_CMD_RXLEN);
|
sprdwl_rx_mh_data_process(rx_if, tran_data, len,
|
msg->buffer_type);
|
tran_data = NULL;
|
data = NULL;
|
break;
|
case SPRDWL_TYPE_DATA_PCIE_ADDR:
|
if (msg->len > SPRDWL_MAX_CMD_RXLEN)
|
wl_err("err rx mh data too long:%d > %d\n",
|
len, SPRDWL_MAX_DATA_RXLEN);
|
sprdwl_rx_mh_addr_process(rx_if, tran_data, len,
|
msg->buffer_type);
|
tran_data = NULL;
|
data = NULL;
|
break;
|
default:
|
wl_err("rx unknown type:%d\n",
|
SPRDWL_HEAD_GET_TYPE(data));
|
break;
|
}
|
free:
|
/* Marlin3 should release buffer by ourself */
|
if (tran_data)
|
sprdwl_free_data(tran_data, msg->buffer_type);
|
|
if (!pos) {
|
wl_debug("%s no mbuf\n", __func__);
|
break;
|
}
|
}
|
next:
|
/* TODO: Should we free mbuf one by one? */
|
sprdwl_free_rx_data(intf, msg->fifo_id, msg->tran_data,
|
msg->data, msg->len);
|
sprdwl_dequeue_msg_buf(msg, &rx_if->rx_data_list);
|
quota--;
|
}
|
|
done = budget - quota;
|
if (done <= 1)
|
napi_complete(napi);
|
|
return done;
|
}
|
|
void sprdwl_rx_napi_init(struct net_device *ndev, struct sprdwl_intf *intf)
|
{
|
struct sprdwl_rx_if *rx_if = (struct sprdwl_rx_if *)intf->sprdwl_rx;
|
|
netif_napi_add(ndev, &rx_if->napi_rx, sprdwl_netdev_poll_rx, 16);
|
napi_enable(&rx_if->napi_rx);
|
}
|
#endif
|
|
int sprdwl_rx_init(struct sprdwl_intf *intf)
|
{
|
int ret = 0;
|
struct sprdwl_rx_if *rx_if = NULL;
|
|
rx_if = kzalloc(sizeof(*rx_if), GFP_KERNEL);
|
if (!rx_if) {
|
ret = -ENOMEM;
|
goto err_rx_if;
|
}
|
|
/* init rx_list */
|
ret = sprdwl_msg_init(SPRDWL_RX_MSG_NUM, &rx_if->rx_list);
|
if (ret) {
|
wl_err("%s tx_buf create failed: %d\n",
|
__func__, ret);
|
goto err_rx_list;
|
}
|
|
#ifdef RX_NAPI
|
ret = sprdwl_msg_init(SPRDWL_RX_MSG_NUM, &rx_if->rx_data_list);
|
if (ret) {
|
wl_err("%s tx_buf create failed: %d\n",
|
__func__, ret);
|
goto err_rx_data_list;
|
}
|
#endif
|
|
/* init rx_work */
|
rx_if->rx_queue =
|
alloc_ordered_workqueue("SPRDWL_RX_QUEUE", WQ_MEM_RECLAIM |
|
WQ_HIGHPRI | WQ_CPU_INTENSIVE);
|
if (!rx_if->rx_queue) {
|
wl_err("%s SPRDWL_RX_QUEUE create failed\n", __func__);
|
ret = -ENOMEM;
|
goto err_rx_work;
|
}
|
|
/*init rx_queue*/
|
INIT_WORK(&rx_if->rx_work, sprdwl_rx_work_queue);
|
|
#ifdef SPLIT_STACK
|
rx_if->rx_net_workq = alloc_ordered_workqueue("SPRDWL_RX_NET_QUEUE",
|
WQ_HIGHPRI | WQ_CPU_INTENSIVE |
|
WQ_MEM_RECLAIM);
|
if (!rx_if->rx_net_workq) {
|
wl_err("%s SPRDWL_RX_NET_QUEUE create failed\n", __func__);
|
ret = -ENOMEM;
|
goto err_rx_net_work;
|
}
|
|
/*init rx_queue*/
|
INIT_WORK(&rx_if->rx_net_work, sprdwl_rx_net_work_queue);
|
#endif
|
|
ret = sprdwl_defrag_init(&rx_if->defrag_entry);
|
if (ret) {
|
wl_err("%s init defrag fail: %d\n", __func__, ret);
|
goto err_rx_defrag;
|
}
|
|
ret = sprdwl_mm_init(&rx_if->mm_entry, (void *)intf);
|
if (ret) {
|
wl_err("%s init mm fail: %d\n", __func__, ret);
|
goto err_rx_mm;
|
}
|
|
sprdwl_reorder_init(&rx_if->ba_entry);
|
|
intf->lp = 0;
|
intf->sprdwl_rx = (void *)rx_if;
|
rx_if->intf = intf;
|
|
return ret;
|
|
err_rx_mm:
|
sprdwl_mm_deinit(&rx_if->mm_entry, intf);
|
err_rx_defrag:
|
#ifdef SPLIT_STACK
|
destroy_workqueue(rx_if->rx_net_workq);
|
err_rx_net_work:
|
#endif
|
destroy_workqueue(rx_if->rx_queue);
|
err_rx_work:
|
#ifdef RX_NAPI
|
sprdwl_msg_deinit(&rx_if->rx_data_list);
|
err_rx_data_list:
|
#endif
|
sprdwl_msg_deinit(&rx_if->rx_list);
|
err_rx_list:
|
kfree(rx_if);
|
err_rx_if:
|
return ret;
|
}
|
|
int sprdwl_rx_deinit(struct sprdwl_intf *intf)
|
{
|
struct sprdwl_rx_if *rx_if = (struct sprdwl_rx_if *)intf->sprdwl_rx;
|
|
flush_workqueue(rx_if->rx_queue);
|
destroy_workqueue(rx_if->rx_queue);
|
|
#ifdef SPLIT_STACK
|
flush_workqueue(rx_if->rx_net_workq);
|
destroy_workqueue(rx_if->rx_net_workq);
|
#endif
|
|
sprdwl_msg_deinit(&rx_if->rx_list);
|
#ifdef RX_NAPI
|
sprdwl_msg_deinit(&rx_if->rx_data_list);
|
napi_disable(&rx_if->napi_rx);
|
#endif
|
|
sprdwl_defrag_deinit(&rx_if->defrag_entry);
|
sprdwl_mm_deinit(&rx_if->mm_entry, intf);
|
sprdwl_reorder_deinit(&rx_if->ba_entry);
|
|
kfree(rx_if);
|
intf->sprdwl_rx = NULL;
|
|
return 0;
|
}
|
