Google Git
Sign in
nest-open-source / manifest_repos / nxp-driver / 1acb4b26622038d5303898336f9bd4c746fb9dc0 / . / wlan_sd8987 / mlan / mlan_usb.c
blob: 98232f07f864e1facd5724189c41ea45f08f0638 [file] [log] [blame]
/** @file mlan_usb.c
*
* @brief This file contains USB specific code
*
*
* Copyright 2008-2021 NXP
*
* This software file (the File) is distributed by NXP
* under the terms of the GNU General Public License Version 2, June 1991
* (the License). You may use, redistribute and/or modify the File in
* accordance with the terms and conditions of the License, a copy of which
* is available by writing to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
* worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
*
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
* this warranty disclaimer.
*
*/
/********************************************************
Change log:
04/21/2009: initial version
********************************************************/
#include "mlan.h"
#ifdef STA_SUPPORT
#include "mlan_join.h"
#endif
#include "mlan_util.h"
#include "mlan_init.h"
#include "mlan_fw.h"
#include "mlan_main.h"
/********************************************************
Local Variables
********************************************************/
#ifdef USB8801
static const struct _mlan_card_info mlan_card_info_usb8801 = {
.max_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_2K,
.v14_fw_api = 1,
.v16_fw_api = 0,
.supp_ps_handshake = 1,
.default_11n_tx_bf_cap = DEFAULT_11N_TX_BF_CAP_1X1,
};
#endif
#ifdef USB8897
static const struct _mlan_card_info mlan_card_info_usb8897 = {
.max_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_4K,
.v16_fw_api = 0,
.supp_ps_handshake = 1,
.default_11n_tx_bf_cap = DEFAULT_11N_TX_BF_CAP_2X2,
};
#endif
#ifdef USB8997
static const struct _mlan_card_info mlan_card_info_usb8997 = {
.max_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_4K,
.v16_fw_api = 1,
.supp_ps_handshake = 1,
.default_11n_tx_bf_cap = DEFAULT_11N_TX_BF_CAP_2X2,
};
#endif
#ifdef USB8978
static const struct _mlan_card_info mlan_card_info_usb8978 = {
.max_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_4K,
.v16_fw_api = 1,
.supp_ps_handshake = 1,
.default_11n_tx_bf_cap = DEFAULT_11N_TX_BF_CAP_2X2,
};
#endif
#ifdef USB9098
static const struct _mlan_card_info mlan_card_info_usb9098 = {
.max_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_4K,
.v16_fw_api = 1,
.v17_fw_api = 1,
.supp_ps_handshake = 1,
.default_11n_tx_bf_cap = DEFAULT_11N_TX_BF_CAP_2X2,
};
#endif
#ifdef USB9097
static const struct _mlan_card_info mlan_card_info_usb9097 = {
.max_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_4K,
.v16_fw_api = 1,
.v17_fw_api = 1,
.supp_ps_handshake = 1,
.default_11n_tx_bf_cap = DEFAULT_11N_TX_BF_CAP_2X2,
};
#endif
/********************************************************
Global Variables
********************************************************/
/********************************************************
Local Functions
********************************************************/
#if defined(USB9098)
/**
* @This function checks the chip revision id
*
* @param pmadapter A pointer to mlan_adapter structure
* @param rev_id A pointer to chip revision id
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
static mlan_status
wlan_usb_check_revision(mlan_adapter *pmadapter, t_u32 *rev_id)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
pmlan_callbacks pcb = &pmadapter->callbacks;
mlan_buffer mbuf;
t_u8 *tx_buff = MNULL;
t_u8 *recv_buff = MNULL;
t_u8 tx_size = 16;
FWSyncPkt syncpkt;
ENTER();
/* Allocate memory for transmit */
ret = pcb->moal_malloc(pmadapter->pmoal_handle, FW_DNLD_TX_BUF_SIZE,
MLAN_MEM_DEF | MLAN_MEM_DMA, (t_u8 **)&tx_buff);
if ((ret != MLAN_STATUS_SUCCESS) || !tx_buff) {
PRINTM(MERROR, "Could not allocate buffer for FW download\n");
LEAVE();
return MLAN_STATUS_FAILURE;
}
/* Allocate memory for receive */
ret = pcb->moal_malloc(pmadapter->pmoal_handle, FW_DNLD_RX_BUF_SIZE,
MLAN_MEM_DEF | MLAN_MEM_DMA, &recv_buff);
if ((ret != MLAN_STATUS_SUCCESS) || !recv_buff) {
PRINTM(MERROR,
"Could not allocate buffer for FW download response\n");
goto cleanup;
}
memset(pmadapter, &syncpkt, 0, sizeof(FWSyncPkt));
memset(pmadapter, &mbuf, 0, sizeof(mlan_buffer));
mbuf.pbuf = (t_u8 *)tx_buff;
mbuf.data_len = tx_size;
ret = pcb->moal_write_data_sync(pmadapter->pmoal_handle, &mbuf,
pmadapter->tx_cmd_ep,
MLAN_USB_BULK_MSG_TIMEOUT);
if (ret != MLAN_STATUS_SUCCESS) {
PRINTM(MERROR, "check revision: write_data failed, ret %d\n",
ret);
goto cleanup;
}
memset(pmadapter, &mbuf, 0, sizeof(mlan_buffer));
mbuf.pbuf = (t_u8 *)recv_buff;
mbuf.data_len = 2048;
ret = pcb->moal_read_data_sync(pmadapter->pmoal_handle, &mbuf,
pmadapter->rx_cmd_ep,
MLAN_USB_BULK_MSG_TIMEOUT);
if (ret != MLAN_STATUS_SUCCESS) {
PRINTM(MERROR, "check revision: read_data failed, ret %d\n",
ret);
goto cleanup;
}
memcpy_ext(pmadapter, &syncpkt, recv_buff, sizeof(syncpkt),
sizeof(syncpkt));
syncpkt.chip_rev = wlan_le32_to_cpu(syncpkt.chip_rev);
*rev_id = syncpkt.chip_rev & 0x000000ff;
PRINTM(MERROR, "chip_revision_id = %d\n", syncpkt.chip_rev);
cleanup:
if (recv_buff)
pcb->moal_mfree(pmadapter->pmoal_handle, recv_buff);
if (tx_buff)
pcb->moal_mfree(pmadapter->pmoal_handle, tx_buff);
LEAVE();
return ret;
}
#endif
/**
* @brief This function downloads FW blocks to device
*
* @param pmadapter A pointer to mlan_adapter
* @param pmfw A pointer to firmware image
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
static mlan_status
wlan_usb_prog_fw_w_helper(pmlan_adapter pmadapter, pmlan_fw_image pmfw)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
pmlan_callbacks pcb = &pmadapter->callbacks;
t_u8 *firmware = pmfw->pfw_buf, *RecvBuff;
t_u32 retries = MAX_FW_RETRY, DataLength;
t_u32 FWSeqNum = 0, TotalBytes = 0, DnldCmd = 0;
t_u8 *TxBuff = MNULL;
FWData *fwdata = MNULL;
FWSyncHeader SyncFWHeader;
t_u8 check_winner = 1;
t_u8 check_fw_status = MFALSE;
t_u8 mic_retry = MAX_FW_RETRY;
#if defined(USB9098)
t_u32 revision_id = 0;
#endif
ENTER();
if (!firmware && !pcb->moal_get_fw_data) {
PRINTM(MMSG, "No firmware image found! Terminating download\n");
ret = MLAN_STATUS_FAILURE;
goto fw_exit;
}
/* Allocate memory for transmit */
ret = pcb->moal_malloc(pmadapter->pmoal_handle, FW_DNLD_TX_BUF_SIZE,
MLAN_MEM_DEF | MLAN_MEM_DMA, (t_u8 **)&TxBuff);
if ((ret != MLAN_STATUS_SUCCESS) || !TxBuff) {
PRINTM(MERROR, "Could not allocate buffer for FW download\n");
goto fw_exit;
}
fwdata = (FWData *)TxBuff;
/* Allocate memory for receive */
ret = pcb->moal_malloc(pmadapter->pmoal_handle, FW_DNLD_RX_BUF_SIZE,
MLAN_MEM_DEF | MLAN_MEM_DMA, &RecvBuff);
if ((ret != MLAN_STATUS_SUCCESS) || !RecvBuff) {
PRINTM(MERROR,
"Could not allocate buffer for FW download response\n");
goto cleanup;
}
if (!IS_USB_NEW_INIT(pmadapter->feature_control))
check_winner = 0;
#if defined(USB9098)
if (IS_USB9098(pmadapter->card_type)) {
ret = wlan_usb_check_revision(pmadapter, &revision_id);
if (ret != MLAN_STATUS_SUCCESS) {
PRINTM(MERROR, "Failed to get USB chip revision ID\n");
goto cleanup;
}
/* Skyhawk A0, need to check both CRC and MIC error */
if (revision_id >= CHIP_9098_REV_A0)
check_fw_status = MTRUE;
}
#endif
#if defined(USB9097)
if (IS_USB9097(pmadapter->card_type))
check_fw_status = MTRUE;
#endif
do {
/* Send pseudo data to check winner status first */
if (check_winner) {
memset(pmadapter, &fwdata->fw_header, 0,
sizeof(FWHeader));
DataLength = 0;
} else {
/* Copy the header of the firmware data to get the
* length */
if (firmware)
memcpy_ext(pmadapter, &fwdata->fw_header,
&firmware[TotalBytes],
sizeof(FWHeader),
sizeof(fwdata->fw_header));
else
pcb->moal_get_fw_data(pmadapter->pmoal_handle,
TotalBytes,
sizeof(FWHeader),
(t_u8 *)&fwdata->
fw_header);
DataLength =
wlan_le32_to_cpu(fwdata->fw_header.data_length);
DnldCmd = wlan_le32_to_cpu(fwdata->fw_header.dnld_cmd);
TotalBytes += sizeof(FWHeader);
/** CMD 7 don't have data_length field */
if (DnldCmd == FW_CMD_4 || DnldCmd == FW_CMD_6 ||
DnldCmd == FW_CMD_7 || DnldCmd == FW_CMD_10)
DataLength = 0;
if (DataLength >
(FW_DNLD_TX_BUF_SIZE - sizeof(FWHeader))) {
PRINTM(MERROR,
"Invalid Data Legth read from FW\n");
ret = MLAN_STATUS_FAILURE;
break;
}
/* Copy the firmware data */
if (firmware)
memcpy_ext(pmadapter, fwdata->data,
&firmware[TotalBytes], DataLength,
DataLength);
else
pcb->moal_get_fw_data(pmadapter->pmoal_handle,
TotalBytes, DataLength,
(t_u8 *)fwdata->data);
fwdata->seq_num = wlan_cpu_to_le32(FWSeqNum);
TotalBytes += DataLength;
}
/* If the send/receive fails or CRC occurs then retry */
while (retries) {
mlan_buffer mbuf;
int length = FW_DATA_XMIT_SIZE;
retries--;
memset(pmadapter, &mbuf, 0, sizeof(mlan_buffer));
mbuf.pbuf = (t_u8 *)fwdata;
mbuf.data_len = length;
/* Send the firmware block */
ret = pcb->moal_write_data_sync(pmadapter->pmoal_handle,
&mbuf,
pmadapter->tx_cmd_ep,
MLAN_USB_BULK_MSG_TIMEOUT);
if (ret != MLAN_STATUS_SUCCESS) {
PRINTM(MERROR,
"fw_dnld: write_data failed, ret %d\n",
ret);
continue;
}
memset(pmadapter, &mbuf, 0, sizeof(mlan_buffer));
mbuf.pbuf = RecvBuff;
mbuf.data_len = FW_DNLD_RX_BUF_SIZE;
/* Receive the firmware block response */
ret = pcb->moal_read_data_sync(pmadapter->pmoal_handle,
&mbuf,
pmadapter->rx_cmd_ep,
MLAN_USB_BULK_MSG_TIMEOUT);
if (ret != MLAN_STATUS_SUCCESS) {
PRINTM(MERROR,
"fw_dnld: read_data failed, ret %d\n",
ret);
continue;
}
memcpy_ext(pmadapter, &SyncFWHeader, RecvBuff,
sizeof(FWSyncHeader), sizeof(SyncFWHeader));
endian_convert_syncfwheader(&SyncFWHeader);
/* Check the first firmware block response for highest
* bit set */
if (check_winner) {
if (SyncFWHeader.cmd & 0x80000000) {
PRINTM(MMSG,
"USB is not the winner 0x%x, returning success\n",
SyncFWHeader.cmd);
ret = MLAN_STATUS_SUCCESS;
goto cleanup;
}
PRINTM(MINFO,
"USB is the winner, start to download FW\n");
check_winner = 0;
break;
}
/* Check the firmware block response for CRC errors */
if (SyncFWHeader.cmd) {
/* Check firmware block response for CRC and MIC
* errors */
if (check_fw_status) {
if (SyncFWHeader.status & MBIT(0)) {
PRINTM(MERROR,
"FW received Blk with CRC error 0x%x offset=%d\n",
SyncFWHeader.status,
SyncFWHeader.offset);
ret = MLAN_STATUS_FAILURE;
continue;
}
if (SyncFWHeader.status &
(MBIT(6) | MBIT(7))) {
PRINTM(MERROR,
"FW received Blk with MIC error 0x%x offset\n",
SyncFWHeader.status,
SyncFWHeader.offset);
mic_retry--;
FWSeqNum = 0;
TotalBytes = 0;
ret = MLAN_STATUS_FAILURE;
continue;
}
} else {
PRINTM(MERROR,
"FW received Blk with CRC error 0x%x\n",
SyncFWHeader.cmd);
ret = MLAN_STATUS_FAILURE;
continue;
}
}
retries = MAX_FW_RETRY;
break;
}
FWSeqNum++;
PRINTM(MINFO, ".\n");
} while ((DnldCmd != FW_HAS_LAST_BLOCK) && retries && mic_retry);
cleanup:
PRINTM(MMSG, "fw_dnld: %d bytes downloaded\n", TotalBytes);
if (RecvBuff)
pcb->moal_mfree(pmadapter->pmoal_handle, RecvBuff);
if (TxBuff)
pcb->moal_mfree(pmadapter->pmoal_handle, TxBuff);
if (retries && mic_retry) {
ret = MLAN_STATUS_SUCCESS;
}
fw_exit:
LEAVE();
return ret;
}
/**
* @brief Get number of packets when deaggregated
*
* @param pmadapter A pointer to mlan_adapter
* @param pdata A pointer to packet data
* @param aggr_pkt_len Aggregate packet length
*
* @return Number of packets
*/
static int
wlan_usb_deaggr_rx_num_pkts(pmlan_adapter pmadapter, t_u8 *pdata,
int aggr_pkt_len)
{
int pkt_count = 0, pkt_len;
RxPD *prx_pd;
ENTER();
while (aggr_pkt_len >= (int)sizeof(RxPD)) {
prx_pd = (RxPD *)pdata;
pkt_len = wlan_le16_to_cpu(prx_pd->rx_pkt_length) +
wlan_le16_to_cpu(prx_pd->rx_pkt_offset);
if (pkt_len == 0) /* blank RxPD can be at the end */
break;
++pkt_count;
if (aggr_pkt_len == pkt_len) /* last packet has no padding */
break;
/* skip padding and goto next */
if (pkt_len %
pmadapter->pcard_usb->usb_rx_deaggr.aggr_ctrl.aggr_align)
pkt_len +=
(pmadapter->pcard_usb->usb_rx_deaggr.aggr_ctrl.
aggr_align -
(pkt_len %
pmadapter->pcard_usb->usb_rx_deaggr.aggr_ctrl.
aggr_align));
aggr_pkt_len -= pkt_len;
pdata += pkt_len;
}
LEAVE();
return pkt_count;
}
static inline t_u32
usb_tx_aggr_pad_len(t_u32 len, usb_tx_aggr_params *pusb_tx_aggr)
{
return (len % pusb_tx_aggr->aggr_ctrl.aggr_align) ?
(len + (pusb_tx_aggr->aggr_ctrl.aggr_align -
(len % pusb_tx_aggr->aggr_ctrl.aggr_align))) : len;
}
/**
* @brief Copy pmbuf to aggregation buffer
*
* @param pmadapter Pointer to mlan_adapter structure
* @param pmbuf_aggr Pointer to aggregation buffer
* @param pmbuf Pointer to buffer to copy
* @param pusb_tx_aggr Pointer to usb_tx_aggr_params
*
* @return N/A
*/
static inline t_void
wlan_usb_tx_copy_buf_to_aggr(pmlan_adapter pmadapter, pmlan_buffer pmbuf_aggr,
pmlan_buffer pmbuf,
usb_tx_aggr_params *pusb_tx_aggr)
{
ENTER();
pmbuf_aggr->data_len =
usb_tx_aggr_pad_len(pmbuf_aggr->data_len, pusb_tx_aggr);
memcpy_ext(pmadapter,
pmbuf_aggr->pbuf + pmbuf_aggr->data_offset +
pmbuf_aggr->data_len,
pmbuf->pbuf + pmbuf->data_offset, pmbuf->data_len,
pmbuf->data_len);
pmbuf_aggr->data_len += pmbuf->data_len;
LEAVE();
}
#define MLAN_TYPE_AGGR_DATA_V2 11
/**
* @brief Copy pmbuf to aggregation buffer
*
* @param pmadapter Pointer to mlan_adapter structure
* @param pmbuf_aggr Pointer to aggregation buffer
* @param pmbuf Pointer to buffer to copy
* @param last last packet flag
* @param pusb_tx_aggr Pointer to usb_tx_aggr_params
*
* @return N/A
*/
static inline t_void
wlan_usb_tx_copy_buf_to_aggr_v2(pmlan_adapter pmadapter,
pmlan_buffer pmbuf_aggr, pmlan_buffer pmbuf,
t_u8 last, usb_tx_aggr_params *pusb_tx_aggr)
{
t_u8 *payload;
t_u16 offset;
ENTER();
pmbuf_aggr->data_len =
usb_tx_aggr_pad_len(pmbuf_aggr->data_len, pusb_tx_aggr);
memcpy_ext(pmadapter,
pmbuf_aggr->pbuf + pmbuf_aggr->data_offset +
pmbuf_aggr->data_len,
pmbuf->pbuf + pmbuf->data_offset, pmbuf->data_len,
pmbuf->data_len);
payload = pmbuf_aggr->pbuf + pmbuf_aggr->data_offset +
pmbuf_aggr->data_len;
if (last) {
offset = pmbuf->data_len;
*(t_u16 *)&payload[2] =
wlan_cpu_to_le16(MLAN_TYPE_AGGR_DATA_V2 | 0x80);
} else {
offset = usb_tx_aggr_pad_len(pmbuf->data_len, pusb_tx_aggr);
*(t_u16 *)&payload[2] =
wlan_cpu_to_le16(MLAN_TYPE_AGGR_DATA_V2);
}
*(t_u16 *)&payload[0] = wlan_cpu_to_le16(offset);
pmbuf_aggr->data_len += pmbuf->data_len;
PRINTM(MIF_D, "offset=%d len=%d\n", offset, pmbuf->data_len);
LEAVE();
}
/**
* @brief Allocate Aggregation buffer and copy pending buffers to it.
*
* @param pmadapter Pointer to mlan_adapter structure
* @param pusb_tx_aggr Pointer to usb_tx_aggr_params
*
* @return Aggregation buffer
*/
static inline pmlan_buffer
wlan_usb_copy_buf_to_aggr(pmlan_adapter pmadapter,
usb_tx_aggr_params *pusb_tx_aggr)
{
pmlan_buffer pmbuf_aggr = MNULL;
t_u8 i, use_count;
pmlan_buffer pmbuf_curr, pmbuf_next;
pmbuf_aggr = wlan_alloc_mlan_buffer(pmadapter, pusb_tx_aggr->aggr_len,
0, MOAL_MALLOC_BUFFER);
if (pmbuf_aggr) {
pmbuf_curr = pusb_tx_aggr->pmbuf_aggr;
pmbuf_aggr->bss_index = pmbuf_curr->bss_index;
pmbuf_aggr->buf_type = pmbuf_curr->buf_type;
pmbuf_aggr->priority = pmbuf_curr->priority;
pmbuf_aggr->data_len = 0;
PRINTM(MIF_D, "use_count=%d,aggr_len=%d\n",
pmbuf_curr->use_count, pusb_tx_aggr->aggr_len);
use_count = pmbuf_curr->use_count;
for (i = 0; i <= use_count; i++) {
pmbuf_next = pmbuf_curr->pnext;
if (pusb_tx_aggr->aggr_ctrl.aggr_mode ==
MLAN_USB_AGGR_MODE_LEN_V2) {
if (i == use_count)
wlan_usb_tx_copy_buf_to_aggr_v2
(pmadapter, pmbuf_aggr,
pmbuf_curr, MTRUE,
pusb_tx_aggr);
else
wlan_usb_tx_copy_buf_to_aggr_v2
(pmadapter, pmbuf_aggr,
pmbuf_curr, MFALSE,
pusb_tx_aggr);
} else
wlan_usb_tx_copy_buf_to_aggr(pmadapter,
pmbuf_aggr,
pmbuf_curr,
pusb_tx_aggr);
pmbuf_curr = pmbuf_next;
}
DBG_HEXDUMP(MIF_D, "USB AggrTx",
pmbuf_aggr->pbuf + pmbuf_aggr->data_offset,
pmbuf_aggr->data_len);
}
return pmbuf_aggr;
}
/**
* @brief Link buffer into aggregate head buffer
*
* @param pmbuf_aggr Pointer to aggregation buffer
* @param pmbuf Pointer to buffer to add to the buffer list
* @param pusb_tx_aggr Pointer to usb_tx_aggr_params
*/
static inline t_void
wlan_usb_tx_link_buf_to_aggr(pmlan_buffer pmbuf_aggr, pmlan_buffer pmbuf,
usb_tx_aggr_params *pusb_tx_aggr)
{
/* link new buf at end of list */
pmbuf->pnext = pmbuf_aggr;
pmbuf->pprev = pmbuf_aggr->pprev;
pmbuf->pparent = pmbuf_aggr;
pmbuf_aggr->pprev->pnext = pmbuf;
pmbuf_aggr->pprev = pmbuf;
pmbuf_aggr->use_count++;
pusb_tx_aggr->aggr_len =
usb_tx_aggr_pad_len(pusb_tx_aggr->aggr_len, pusb_tx_aggr);
pusb_tx_aggr->aggr_len += pmbuf->data_len;
}
/**
* @brief Send aggregated buffer
*
* @param pmadapter Pointer to mlan_adapter structure
* @param pusb_tx_aggr Pointer to usb_tx_aggr_params
*/
static inline t_void
wlan_usb_tx_send_aggr(pmlan_adapter pmadapter, usb_tx_aggr_params *pusb_tx_aggr)
{
mlan_status ret;
pmlan_buffer pmbuf_aggr = pusb_tx_aggr->pmbuf_aggr;
ENTER();
if (!pusb_tx_aggr->pmbuf_aggr) {
LEAVE();
return;
}
if (pusb_tx_aggr->pmbuf_aggr->use_count) {
pmbuf_aggr = wlan_usb_copy_buf_to_aggr(pmadapter, pusb_tx_aggr);
/* allocate new buffer for aggregation if not exist */
if (!pmbuf_aggr) {
PRINTM(MERROR,
"Error allocating [usb_tx] aggr mlan_buffer.\n");
pmadapter->dbg.num_tx_host_to_card_failure +=
pusb_tx_aggr->pmbuf_aggr->use_count;
wlan_write_data_complete(pmadapter,
pusb_tx_aggr->pmbuf_aggr,
MLAN_STATUS_FAILURE);
pusb_tx_aggr->pmbuf_aggr = MNULL;
pusb_tx_aggr->aggr_len = 0;
LEAVE();
return;
} else {
wlan_write_data_complete(pmadapter,
pusb_tx_aggr->pmbuf_aggr,
MLAN_STATUS_SUCCESS);
pusb_tx_aggr->pmbuf_aggr = MNULL;
pusb_tx_aggr->aggr_len = 0;
}
} else if (pusb_tx_aggr->aggr_ctrl.aggr_mode ==
MLAN_USB_AGGR_MODE_LEN_V2) {
t_u8 *payload = pmbuf_aggr->pbuf + pmbuf_aggr->data_offset;
*(t_u16 *)&payload[0] = wlan_cpu_to_le16(pmbuf_aggr->data_len);
*(t_u16 *)&payload[2] =
wlan_cpu_to_le16(MLAN_TYPE_AGGR_DATA_V2 | 0x80);
PRINTM(MIF_D, "USB Send single packet len=%d\n",
pmbuf_aggr->data_len);
DBG_HEXDUMP(MIF_D, "USB Tx",
pmbuf_aggr->pbuf + pmbuf_aggr->data_offset,
pmbuf_aggr->data_len);
}
if (pmbuf_aggr && pmbuf_aggr->data_len) {
pmadapter->data_sent = MTRUE;
ret = pmadapter->callbacks.moal_write_data_async(pmadapter->
pmoal_handle,
pmbuf_aggr,
pusb_tx_aggr->
port);
switch (ret) {
case MLAN_STATUS_PRESOURCE:
PRINTM(MINFO, "MLAN_STATUS_PRESOURCE is returned\n");
break;
case MLAN_STATUS_RESOURCE:
/* Shouldn't reach here due to next condition. */
/* TODO: (maybe) How to requeue the aggregate? */
/* It may occur when the pending tx urbs reach the high
* mark */
/* Thus, block further pkts for a bit */
PRINTM(MERROR,
"Error: moal_write_data_async failed: 0x%X\n",
ret);
pmadapter->dbg.num_tx_host_to_card_failure++;
pmbuf_aggr->status_code = MLAN_ERROR_DATA_TX_FAIL;
wlan_write_data_complete(pmadapter, pmbuf_aggr, ret);
break;
case MLAN_STATUS_FAILURE:
pmadapter->data_sent = MFALSE;
PRINTM(MERROR,
"Error: moal_write_data_async failed: 0x%X\n",
ret);
pmadapter->dbg.num_tx_host_to_card_failure++;
pmbuf_aggr->status_code = MLAN_ERROR_DATA_TX_FAIL;
wlan_write_data_complete(pmadapter, pmbuf_aggr, ret);
break;
case MLAN_STATUS_PENDING:
pmadapter->data_sent = MFALSE;
break;
case MLAN_STATUS_SUCCESS:
wlan_write_data_complete(pmadapter, pmbuf_aggr, ret);
break;
default:
break;
}
/* aggr_buf now sent to bus, prevent others from using it */
pusb_tx_aggr->pmbuf_aggr = MNULL;
pusb_tx_aggr->aggr_len = 0;
}
LEAVE();
}
/********************************************************
Global Functions
********************************************************/
/**
* @brief This function get pcie device from card type
*
* @param pmadapter A pointer to mlan_adapter structure
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_get_usb_device(pmlan_adapter pmadapter)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
t_u16 card_type = pmadapter->card_type;
ENTER();
ret = pmadapter->callbacks.moal_malloc(pmadapter->pmoal_handle,
sizeof(mlan_usb_card),
MLAN_MEM_DEF,
(t_u8 **)&pmadapter->pcard_usb);
if (ret != MLAN_STATUS_SUCCESS || !pmadapter->pcard_usb) {
PRINTM(MERROR, "Failed to allocate pcard_usb\n");
LEAVE();
return MLAN_STATUS_FAILURE;
}
switch (card_type) {
#ifdef USB8801
case CARD_TYPE_USB8801:
pmadapter->pcard_info = &mlan_card_info_usb8801;
break;
#endif
#ifdef USB8897
case CARD_TYPE_USB8897:
pmadapter->pcard_info = &mlan_card_info_usb8897;
break;
#endif
#ifdef USB8997
case CARD_TYPE_USB8997:
pmadapter->pcard_info = &mlan_card_info_usb8997;
break;
#endif
#ifdef USB8978
case CARD_TYPE_USB8978:
pmadapter->pcard_info = &mlan_card_info_usb8978;
break;
#endif
#ifdef USB9098
case CARD_TYPE_USB9098:
pmadapter->pcard_info = &mlan_card_info_usb9098;
break;
#endif
#ifdef USB9097
case CARD_TYPE_USB9097:
pmadapter->pcard_info = &mlan_card_info_usb9097;
break;
#endif
default:
PRINTM(MERROR, "can't get right USB card type \n");
ret = MLAN_STATUS_FAILURE;
break;
}
LEAVE();
return ret;
}
/**
* @brief This function downloads firmware to card
*
* @param pmadapter A pointer to mlan_adapter
* @param pmfw A pointer to firmware image
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
static mlan_status
wlan_usb_dnld_fw(pmlan_adapter pmadapter, pmlan_fw_image pmfw)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
ret = wlan_usb_prog_fw_w_helper(pmadapter, pmfw);
if (ret != MLAN_STATUS_SUCCESS) {
LEAVE();
return MLAN_STATUS_FAILURE;
}
LEAVE();
return ret;
}
/**
* @brief This function deaggregates USB RX Data Packet from device
*
* @param pmadapter A pointer to mlan_adapter
* @param pmbuf A pointer to the received buffer
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_usb_deaggr_rx_pkt(pmlan_adapter pmadapter, pmlan_buffer pmbuf)
{
const t_u8 zero_rx_pd[sizeof(RxPD)] = { 0 };
mlan_status ret = MLAN_STATUS_SUCCESS;
t_u32 curr_pkt_len;
RxPD *prx_pd;
t_u8 *pdata;
t_s32 aggr_len;
pmlan_buffer pdeaggr_buf;
ENTER();
pdata = pmbuf->pbuf + pmbuf->data_offset;
prx_pd = (RxPD *)pdata;
curr_pkt_len = wlan_le16_to_cpu(prx_pd->rx_pkt_length) +
wlan_le16_to_cpu(prx_pd->rx_pkt_offset);
/* if non-aggregate, just send through, don’t process here */
aggr_len = pmbuf->data_len;
if ((aggr_len == (t_s32)curr_pkt_len) ||
(wlan_usb_deaggr_rx_num_pkts(pmadapter, pdata, aggr_len) == 1) ||
(pmadapter->pcard_usb->usb_rx_deaggr.aggr_ctrl.enable != MTRUE)) {
ret = wlan_handle_rx_packet(pmadapter, pmbuf);
LEAVE();
return ret;
}
while (aggr_len >= (t_s32)sizeof(RxPD)) {
/* check for (all-zeroes) termination RxPD */
if (!memcmp(pmadapter, pdata, zero_rx_pd, sizeof(RxPD))) {
break;
}
/* make new buffer and copy packet to it (including RxPD).
* Also, reserve headroom so that there must have space
* to change RxPD to TxPD for bridge packet in uAP mode */
pdeaggr_buf = wlan_alloc_mlan_buffer(pmadapter, curr_pkt_len,
MLAN_RX_HEADER_LEN,
MOAL_ALLOC_MLAN_BUFFER);
if (pdeaggr_buf == MNULL) {
PRINTM(MERROR,
"Error allocating [usb_rx] deaggr mlan_buffer\n");
ret = MLAN_STATUS_FAILURE;
break;
}
pdeaggr_buf->bss_index = pmbuf->bss_index;
pdeaggr_buf->buf_type = pmbuf->buf_type;
pdeaggr_buf->data_len = curr_pkt_len;
pdeaggr_buf->in_ts_sec = pmbuf->in_ts_sec;
pdeaggr_buf->in_ts_usec = pmbuf->in_ts_usec;
pdeaggr_buf->priority = pmbuf->priority;
memcpy_ext(pmadapter,
pdeaggr_buf->pbuf + pdeaggr_buf->data_offset, pdata,
curr_pkt_len, pdeaggr_buf->data_len);
/* send new packet to processing */
ret = wlan_handle_rx_packet(pmadapter, pdeaggr_buf);
if (ret == MLAN_STATUS_FAILURE) {
break;
}
/* last block has no padding bytes */
if (aggr_len == (t_s32)curr_pkt_len) {
break;
}
/* round up to next block boundary */
if (curr_pkt_len %
pmadapter->pcard_usb->usb_rx_deaggr.aggr_ctrl.aggr_align)
curr_pkt_len +=
(pmadapter->pcard_usb->usb_rx_deaggr.aggr_ctrl.
aggr_align -
(curr_pkt_len %
pmadapter->pcard_usb->usb_rx_deaggr.aggr_ctrl.
aggr_align));
/* point to next packet */
aggr_len -= curr_pkt_len;
pdata += curr_pkt_len;
prx_pd = (RxPD *)pdata;
curr_pkt_len = wlan_le16_to_cpu(prx_pd->rx_pkt_length) +
wlan_le16_to_cpu(prx_pd->rx_pkt_offset);
}
/* free original pmbuf (since not sent for processing) */
pmadapter->callbacks.moal_recv_complete(pmadapter->pmoal_handle, pmbuf,
pmadapter->rx_data_ep, ret);
LEAVE();
return ret;
}
/**
* @brief This function restore tx_pause flag
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pusb_tx_aggr A pointer to usb_tx_aggr_params
*
* @return MTRUE/MFALSE
*/
static t_u8
wlan_is_port_tx_paused(pmlan_adapter pmadapter,
usb_tx_aggr_params *pusb_tx_aggr)
{
mlan_private *pmpriv = MNULL;
t_u8 i;
t_u8 ret = MFALSE;
for (i = 0; i < pmadapter->priv_num; i++) {
pmpriv = pmadapter->priv[i];
if (pmpriv && pmpriv->tx_pause &&
(pmpriv->port == pusb_tx_aggr->port)) {
ret = MTRUE;
break;
}
}
return ret;
}
/**
* @brief This function handles the timeout of usb tx aggregation.
* It will send the aggregate buffer being held.
*
* @param function_context A pointer to function_context
* @return N/A
*/
t_void
wlan_usb_tx_aggr_timeout_func(t_void *function_context)
{
usb_tx_aggr_params *pusb_tx_aggr =
(usb_tx_aggr_params *)function_context;
pmlan_adapter pmadapter = (mlan_adapter *)pusb_tx_aggr->phandle;
pmlan_callbacks pcb = &pmadapter->callbacks;
ENTER();
pcb->moal_spin_lock(pmadapter->pmoal_handle, pusb_tx_aggr->paggr_lock);
pusb_tx_aggr->aggr_hold_timer_is_set = MFALSE;
if (pusb_tx_aggr->pmbuf_aggr && !pmadapter->data_sent
&& !wlan_is_port_tx_paused(pmadapter, pusb_tx_aggr)
)
wlan_usb_tx_send_aggr(pmadapter, pusb_tx_aggr);
pcb->moal_spin_unlock(pmadapter->pmoal_handle,
pusb_tx_aggr->paggr_lock);
LEAVE();
}
/**
* @brief This function aggregates USB TX Data Packet to send to device
*
* @param pmadapter A pointer to mlan_adapter
* @param pmbuf A pointer to the transmit buffer
* @param tx_param A pointer to mlan_tx_param
* @param pusb_tx_aggr A pointer to usb_tx_aggr_params
*
* @return MLAN_STATUS_PENDING or MLAN_STATUS_FAILURE
*/
/*
* Non Scatter-Gather code creates a new large buffer where each incoming
* buffer's data contents are copied to (aligned to USB boundaries).
* The individual buffers are ALSO linked to the large buffer,
* in order to handle complete AFTER the aggregate is sent.
* pmbuf_aggr->data_len is used to keep track of bytes aggregated so far.
*/
mlan_status
wlan_usb_host_to_card_aggr(pmlan_adapter pmadapter,
pmlan_buffer pmbuf,
mlan_tx_param *tx_param,
usb_tx_aggr_params *pusb_tx_aggr)
{
pmlan_callbacks pcb = &pmadapter->callbacks;
pmlan_buffer pmbuf_aggr;
mlan_status ret = MLAN_STATUS_PENDING;
t_u32 next_pkt_len = (tx_param) ? tx_param->next_pkt_len : 0;
t_u32 aggr_len_counter = 0;
/* indicators */
t_u8 f_precopy_cur_buf = 0;
t_u8 f_send_aggr_buf = 0;
t_u8 f_postcopy_cur_buf = 0;
t_u32 max_aggr_size = 0, max_aggr_num = 0;
ENTER();
pcb->moal_spin_lock(pmadapter->pmoal_handle, pusb_tx_aggr->paggr_lock);
/* stop timer while we process */
if (pusb_tx_aggr->aggr_hold_timer_is_set) {
pcb->moal_stop_timer(pmadapter->pmoal_handle,
pusb_tx_aggr->paggr_hold_timer);
pusb_tx_aggr->aggr_hold_timer_is_set = MFALSE;
}
pmbuf_aggr = pusb_tx_aggr->pmbuf_aggr;
if (pusb_tx_aggr->aggr_ctrl.aggr_tmo == MLAN_USB_TX_AGGR_TIMEOUT_DYN) {
if (!pmbuf_aggr) {
/* Start aggr from min timeout value in micro sec */
pusb_tx_aggr->hold_timeout_msec =
MLAN_USB_TX_MIN_AGGR_TIMEOUT;
} else {
/* Increase timeout in milisecond if pkts are
* consecutive */
if (pusb_tx_aggr->hold_timeout_msec <
MLAN_USB_TX_MAX_AGGR_TIMEOUT)
pusb_tx_aggr->hold_timeout_msec++;
}
} else {
if (pusb_tx_aggr->aggr_ctrl.aggr_tmo)
pusb_tx_aggr->hold_timeout_msec =
pusb_tx_aggr->aggr_ctrl.aggr_tmo / 1000;
}
max_aggr_size = max_aggr_num = pusb_tx_aggr->aggr_ctrl.aggr_max;
if (pusb_tx_aggr->aggr_ctrl.aggr_mode == MLAN_USB_AGGR_MODE_NUM) {
max_aggr_size *= MAX(MLAN_USB_MAX_PKT_SIZE,
pusb_tx_aggr->aggr_ctrl.aggr_align);
}
if (pusb_tx_aggr->aggr_ctrl.aggr_mode == MLAN_USB_AGGR_MODE_LEN)
max_aggr_num /= pusb_tx_aggr->aggr_ctrl.aggr_align;
else if (pusb_tx_aggr->aggr_ctrl.aggr_mode == MLAN_USB_AGGR_MODE_LEN_V2)
max_aggr_num = MLAN_USB_TX_AGGR_MAX_NUM;
if (!pmbuf_aggr) {
/* use this buf to start linked list, that's it */
pmbuf->pnext = pmbuf->pprev = pmbuf;
pmbuf_aggr = pmbuf;
pusb_tx_aggr->pmbuf_aggr = pmbuf_aggr;
pusb_tx_aggr->aggr_len = pmbuf->data_len;
pmbuf->flags |= MLAN_BUF_FLAG_USB_TX_AGGR;
} else {
/* DECIDE what to do */
aggr_len_counter = usb_tx_aggr_pad_len(pusb_tx_aggr->aggr_len,
pusb_tx_aggr);
if ((aggr_len_counter + pmbuf->data_len) < max_aggr_size) {
f_precopy_cur_buf = 1; /* can fit current packet in aggr
*/
if (next_pkt_len) {
aggr_len_counter +=
usb_tx_aggr_pad_len(pmbuf->data_len,
pusb_tx_aggr);
if ((aggr_len_counter + next_pkt_len) >=
max_aggr_size)
f_send_aggr_buf = 1; /* can't fit next
packet, send now
*/
}
} else {
/* can't fit current packet */
if (pusb_tx_aggr->aggr_len)
f_send_aggr_buf = 1; /* send aggr first */
f_postcopy_cur_buf = 1; /* then copy into new aggr_buf
*/
}
}
/* For zero timeout and zero next packet length send pkt now */
if (!pusb_tx_aggr->aggr_ctrl.aggr_tmo && !next_pkt_len)
f_send_aggr_buf = 1;
/* PERFORM ACTIONS as decided */
if (f_precopy_cur_buf) {
PRINTM(MIF_D, "%s: Precopy current buffer.\n", __FUNCTION__);
wlan_usb_tx_link_buf_to_aggr(pmbuf_aggr, pmbuf, pusb_tx_aggr);
}
if (pmbuf_aggr->use_count + 1 >= max_aggr_num)
f_send_aggr_buf = 1;
if (pmbuf->flags & MLAN_BUF_FLAG_NULL_PKT
|| pmbuf->flags & MLAN_BUF_FLAG_TCP_ACK)
f_send_aggr_buf = 1;
if (f_send_aggr_buf) {
PRINTM(MIF_D, "%s: Send aggregate buffer.\n", __FUNCTION__);
wlan_usb_tx_send_aggr(pmadapter, pusb_tx_aggr);
pmbuf_aggr = pusb_tx_aggr->pmbuf_aggr; /* update ptr */
}
if (f_postcopy_cur_buf) {
PRINTM(MIF_D, "%s: Postcopy current buffer.\n", __FUNCTION__);
if (!pmbuf_aggr) { /* this is possible if just sent (above) */
/* use this buf to start linked list */
pmbuf->pnext = pmbuf->pprev = pmbuf;
pmbuf_aggr = pmbuf;
pusb_tx_aggr->pmbuf_aggr = pmbuf_aggr;
pusb_tx_aggr->aggr_len = pmbuf->data_len;
pmbuf->flags |= MLAN_BUF_FLAG_USB_TX_AGGR;
}
}
/* (re)start timer if there is something in the aggregation buffer */
if (pmbuf_aggr && pmbuf_aggr->data_len) {
if (pusb_tx_aggr->aggr_ctrl.aggr_tmo) {
pcb->moal_start_timer(pmadapter->pmoal_handle,
pusb_tx_aggr->paggr_hold_timer,
MFALSE,
pusb_tx_aggr->hold_timeout_msec);
pusb_tx_aggr->aggr_hold_timer_is_set = MTRUE;
}
}
pcb->moal_spin_unlock(pmadapter->pmoal_handle,
pusb_tx_aggr->paggr_lock);
LEAVE();
return ret;
}
/**
* @brief This function wakes up the card.
*
* @param pmadapter A pointer to mlan_adapter structure
* @param timeout set timeout flag
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
static mlan_status
wlan_pm_usb_wakeup_card(pmlan_adapter pmadapter, t_u8 timeout)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
t_u32 age_ts_usec;
ENTER();
PRINTM(MEVENT, "Wakeup device...\n");
pmadapter->callbacks.moal_get_system_time(pmadapter->pmoal_handle,
&pmadapter->pm_wakeup_in_secs,
&age_ts_usec);
/* Simulation of HS_AWAKE event */
pmadapter->pm_wakeup_fw_try = MFALSE;
pmadapter->pm_wakeup_card_req = MFALSE;
/* TODO USB suspend/resume */
pmadapter->ps_state = PS_STATE_AWAKE;
LEAVE();
return ret;
}
/**
* @brief This function downloads data from driver to card.
*
* Both commands and data packets are transferred to the card
* by this function. This function adds the PCIE specific header
* to the front of the buffer before transferring. The header
* contains the length of the packet and the type. The firmware
* handles the packets based upon this set type.
*
* @param pmpriv A pointer to pmlan_private structure
* @param type data or command
* @param pmbuf A pointer to mlan_buffer (pmbuf->data_len should include
* PCIE header)
* @param tx_param A pointer to mlan_tx_param (can be MNULL if type is
* command)
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
static mlan_status
wlan_usb_host_to_card(pmlan_private pmpriv, t_u8 type,
mlan_buffer *pmbuf, mlan_tx_param *tx_param)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
usb_tx_aggr_params *pusb_tx_aggr = MNULL;
pmlan_adapter pmadapter = pmpriv->adapter;
ENTER();
if (!pmbuf) {
PRINTM(MERROR, "Passed NULL pmbuf to %s\n", __FUNCTION__);
return MLAN_STATUS_FAILURE;
}
if (type == MLAN_TYPE_CMD
#if (defined(USB9098) || defined(USB9097))
|| type == MLAN_TYPE_VDLL
#endif
) {
pmadapter->cmd_sent = MTRUE;
ret = pmadapter->callbacks.moal_write_data_async(pmadapter->
pmoal_handle,
pmbuf,
pmadapter->
tx_cmd_ep);
if (ret == MLAN_STATUS_FAILURE)
pmadapter->cmd_sent = MFALSE;
LEAVE();
return ret;
}
pusb_tx_aggr = wlan_get_usb_tx_aggr_params(pmadapter, pmpriv->port);
if (pusb_tx_aggr) {
ret = wlan_usb_host_to_card_aggr(pmadapter, pmbuf, tx_param,
pusb_tx_aggr);
} else {
pmadapter->data_sent = MTRUE;
ret = pmadapter->callbacks.moal_write_data_async(pmadapter->
pmoal_handle,
pmbuf,
pmpriv->port);
switch (ret) {
case MLAN_STATUS_PRESOURCE:
PRINTM(MINFO, "MLAN_STATUS_PRESOURCE is returned\n");
break;
case MLAN_STATUS_RESOURCE:
break;
case MLAN_STATUS_FAILURE:
pmadapter->data_sent = MFALSE;
break;
case MLAN_STATUS_PENDING:
pmadapter->data_sent = MFALSE;
break;
case MLAN_STATUS_SUCCESS:
break;
default:
break;
}
}
LEAVE();
return ret;
}
/**
* @brief This function handle event/cmd complete
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pmbuf A pointer to the mlan_buffer
* @return N/A
*/
static mlan_status
wlan_usb_cmdevt_complete(pmlan_adapter pmadapter,
mlan_buffer *pmbuf, mlan_status status)
{
ENTER();
pmadapter->callbacks.moal_recv_complete(pmadapter->pmoal_handle, pmbuf,
pmadapter->rx_cmd_ep, status);
LEAVE();
return MLAN_STATUS_SUCCESS;
}
/**
* @brief This function handle data complete
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pmbuf A pointer to the mlan_buffer
* @return N/A
*/
static mlan_status
wlan_usb_data_complete(pmlan_adapter pmadapter,
mlan_buffer *pmbuf, mlan_status status)
{
ENTER();
pmadapter->callbacks.moal_recv_complete(pmadapter->pmoal_handle, pmbuf,
pmadapter->rx_data_ep, status);
LEAVE();
return MLAN_STATUS_SUCCESS;
}
/**
* @brief This function handle receive packet
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pmbuf A pointer to the mlan_buffer
* @return
*/
static mlan_status
wlan_usb_handle_rx_packet(mlan_adapter *pmadapter, pmlan_buffer pmbuf)
{
ENTER();
if (pmadapter->pcard_usb->usb_rx_deaggr.aggr_ctrl.enable == MTRUE)
return wlan_usb_deaggr_rx_pkt(pmadapter, pmbuf);
else
return wlan_handle_rx_packet(pmadapter, pmbuf);
LEAVE();
}
mlan_adapter_operations mlan_usb_ops = {
.dnld_fw = wlan_usb_dnld_fw,
.host_to_card = wlan_usb_host_to_card,
.wakeup_card = wlan_pm_usb_wakeup_card,
.event_complete = wlan_usb_cmdevt_complete,
.data_complete = wlan_usb_data_complete,
.cmdrsp_complete = wlan_usb_cmdevt_complete,
.handle_rx_packet = wlan_usb_handle_rx_packet,
.intf_header_len = USB_INTF_HEADER_LEN,
};