2020-12-05 11:42:54 +00:00
|
|
|
/** @file mlan_sdio.c
|
|
|
|
*
|
|
|
|
* @brief This file contains SDIO specific code
|
|
|
|
*
|
|
|
|
*
|
2021-02-24 06:17:59 +00:00
|
|
|
* Copyright 2008-2020 NXP
|
2020-12-05 11:42:54 +00:00
|
|
|
*
|
|
|
|
* 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:
|
|
|
|
10/27/2008: initial version
|
|
|
|
********************************************************/
|
|
|
|
|
|
|
|
#include "mlan.h"
|
|
|
|
#ifdef STA_SUPPORT
|
|
|
|
#include "mlan_join.h"
|
|
|
|
#endif
|
|
|
|
#include "mlan_util.h"
|
|
|
|
#include "mlan_fw.h"
|
|
|
|
#include "mlan_main.h"
|
|
|
|
#include "mlan_init.h"
|
|
|
|
#include "mlan_wmm.h"
|
|
|
|
#include "mlan_11n.h"
|
|
|
|
#include "mlan_sdio.h"
|
|
|
|
|
|
|
|
/********************************************************
|
|
|
|
Local Variables
|
|
|
|
********************************************************/
|
|
|
|
|
|
|
|
/********************************************************
|
|
|
|
Global Variables
|
|
|
|
********************************************************/
|
|
|
|
|
|
|
|
/********************************************************
|
|
|
|
Local Functions
|
|
|
|
********************************************************/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function initialize the SDIO port
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_init_ioport(mlan_adapter *pmadapter)
|
|
|
|
{
|
|
|
|
t_u32 reg;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
t_u8 host_int_rsr_reg = pmadapter->pcard_sd->reg->host_int_rsr_reg;
|
|
|
|
t_u8 host_int_rsr_mask = pmadapter->pcard_sd->reg->sdio_int_mask;
|
|
|
|
t_u8 card_misc_cfg_reg = pmadapter->pcard_sd->reg->card_misc_cfg_reg;
|
|
|
|
t_u8 card_config_2_1_reg =
|
|
|
|
pmadapter->pcard_sd->reg->card_config_2_1_reg;
|
|
|
|
t_u8 cmd_config_0 = pmadapter->pcard_sd->reg->cmd_config_0;
|
|
|
|
t_u8 cmd_config_1 = pmadapter->pcard_sd->reg->cmd_config_1;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
pmadapter->pcard_sd->ioport = MEM_PORT;
|
|
|
|
PRINTM(MINFO, "SDIO FUNC1 IO port: 0x%x\n",
|
|
|
|
pmadapter->pcard_sd->ioport);
|
|
|
|
|
|
|
|
/* enable sdio cmd53 new mode */
|
|
|
|
if (MLAN_STATUS_SUCCESS == pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
card_config_2_1_reg,
|
|
|
|
®)) {
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
card_config_2_1_reg, reg | CMD53_NEW_MODE);
|
|
|
|
} else {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* configure cmd port */
|
|
|
|
/* enable reading rx length from the register */
|
|
|
|
if (MLAN_STATUS_SUCCESS ==
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle, cmd_config_0, ®)) {
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle, cmd_config_0,
|
|
|
|
reg | CMD_PORT_RD_LEN_EN);
|
|
|
|
} else {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
/* enable Dnld/Upld ready auto reset for cmd port
|
|
|
|
* after cmd53 is completed */
|
|
|
|
if (MLAN_STATUS_SUCCESS ==
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle, cmd_config_1, ®)) {
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle, cmd_config_1,
|
|
|
|
reg | CMD_PORT_AUTO_EN);
|
|
|
|
} else {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(SD8977) || defined(SD8978)
|
|
|
|
if (IS_SD8977(pmadapter->card_type) ||
|
|
|
|
IS_SD8978(pmadapter->card_type)) {
|
|
|
|
if ((pmadapter->init_para.int_mode == INT_MODE_GPIO) &&
|
|
|
|
(pmadapter->init_para.gpio_pin == GPIO_INT_NEW_MODE)) {
|
|
|
|
PRINTM(MMSG, "Enable GPIO-1 int mode\n");
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
SCRATCH_REG_32,
|
|
|
|
ENABLE_GPIO_1_INT_MODE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Set Host interrupt reset to read to clear */
|
|
|
|
if (MLAN_STATUS_SUCCESS == pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
host_int_rsr_reg, ®)) {
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle, host_int_rsr_reg,
|
|
|
|
reg | host_int_rsr_mask);
|
|
|
|
} else {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Dnld/Upld ready set to auto reset */
|
|
|
|
if (MLAN_STATUS_SUCCESS == pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
card_misc_cfg_reg,
|
|
|
|
®)) {
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle, card_misc_cfg_reg,
|
|
|
|
reg | AUTO_RE_ENABLE_INT);
|
|
|
|
} else {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function sends data to the card.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pmbuf A pointer to mlan_buffer (pmbuf->data_len should include
|
|
|
|
* SDIO header)
|
|
|
|
* @param port Port
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_write_data_sync(mlan_adapter *pmadapter,
|
|
|
|
mlan_buffer *pmbuf, t_u32 port)
|
|
|
|
{
|
|
|
|
t_u32 i = 0;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
do {
|
|
|
|
ret = pcb->moal_write_data_sync(pmadapter->pmoal_handle, pmbuf,
|
|
|
|
port, 0);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
i++;
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"host_to_card, write iomem (%d) failed: %d\n", i,
|
|
|
|
ret);
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG,
|
|
|
|
HOST_TERM_CMD53)) {
|
|
|
|
PRINTM(MERROR, "write CFG reg failed\n");
|
|
|
|
}
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
if (i > MAX_WRITE_IOMEM_RETRY) {
|
|
|
|
pmbuf->status_code = MLAN_ERROR_DATA_TX_FAIL;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (ret == MLAN_STATUS_FAILURE);
|
|
|
|
exit:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function gets available SDIO port for reading cmd/data
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pport A pointer to port number
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_get_rd_port(mlan_adapter *pmadapter, t_u8 *pport)
|
|
|
|
{
|
|
|
|
t_u32 rd_bitmap = pmadapter->pcard_sd->mp_rd_bitmap;
|
|
|
|
const mlan_sdio_card_reg *reg = pmadapter->pcard_sd->reg;
|
|
|
|
t_u8 max_ports = MAX_PORT;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
PRINTM(MIF_D, "wlan_get_rd_port: mp_rd_bitmap=0x%08x\n", rd_bitmap);
|
|
|
|
|
|
|
|
if (!(rd_bitmap & reg->data_port_mask)) {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->mp_rd_bitmap &
|
|
|
|
(1 << pmadapter->pcard_sd->curr_rd_port)) {
|
|
|
|
pmadapter->pcard_sd->mp_rd_bitmap &=
|
|
|
|
(t_u32)(~(1 << pmadapter->pcard_sd->curr_rd_port));
|
|
|
|
*pport = pmadapter->pcard_sd->curr_rd_port;
|
|
|
|
|
|
|
|
/* hw rx wraps round only after port (MAX_PORT-1) */
|
|
|
|
if (++pmadapter->pcard_sd->curr_rd_port == max_ports)
|
|
|
|
pmadapter->pcard_sd->curr_rd_port = reg->start_rd_port;
|
|
|
|
} else {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRINTM(MIF_D, "port=%d mp_rd_bitmap=0x%08x -> 0x%08x\n", *pport,
|
|
|
|
rd_bitmap, pmadapter->pcard_sd->mp_rd_bitmap);
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function gets available SDIO port for writing data
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pport A pointer to port number
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_get_wr_port_data(mlan_adapter *pmadapter, t_u8 *pport)
|
|
|
|
{
|
|
|
|
t_u32 wr_bitmap = pmadapter->pcard_sd->mp_wr_bitmap;
|
|
|
|
const mlan_sdio_card_reg *reg = pmadapter->pcard_sd->reg;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
PRINTM(MIF_D, "wlan_get_wr_port_data: mp_wr_bitmap=0x%08x\n",
|
|
|
|
wr_bitmap);
|
|
|
|
|
|
|
|
if (!(wr_bitmap & pmadapter->pcard_sd->mp_data_port_mask)) {
|
|
|
|
pmadapter->data_sent = MTRUE;
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_RESOURCE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
(1 << pmadapter->pcard_sd->curr_wr_port)) {
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap &=
|
|
|
|
(t_u32)(~(1 << pmadapter->pcard_sd->curr_wr_port));
|
|
|
|
*pport = pmadapter->pcard_sd->curr_wr_port;
|
|
|
|
if (++pmadapter->pcard_sd->curr_wr_port ==
|
|
|
|
pmadapter->pcard_sd->mp_end_port)
|
|
|
|
pmadapter->pcard_sd->curr_wr_port = reg->start_wr_port;
|
|
|
|
} else {
|
|
|
|
pmadapter->data_sent = MTRUE;
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_RESOURCE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRINTM(MIF_D, "port=%d mp_wr_bitmap=0x%08x -> 0x%08x\n", *pport,
|
|
|
|
wr_bitmap, pmadapter->pcard_sd->mp_wr_bitmap);
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function polls the card status register.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param bits the bit mask
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_poll_card_status(mlan_adapter *pmadapter,
|
|
|
|
t_u8 bits)
|
|
|
|
{
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
t_u32 tries;
|
|
|
|
t_u32 cs = 0;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
|
|
|
|
if (pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pcard_sd->reg->poll_reg,
|
|
|
|
&cs) != MLAN_STATUS_SUCCESS)
|
|
|
|
break;
|
|
|
|
else if ((cs & bits) == bits) {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
wlan_udelay(pmadapter, 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"wlan_sdio_poll_card_status failed, tries = %d, cs = 0x%x\n",
|
|
|
|
tries, cs);
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function reads firmware status registers
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param dat A pointer to keep returned data
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_read_fw_status(mlan_adapter *pmadapter, t_u16 *dat)
|
|
|
|
{
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
t_u32 fws0 = 0, fws1 = 0;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pcard_sd->reg->status_reg_0, &fws0)) {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pcard_sd->reg->status_reg_1, &fws1)) {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dat = (t_u16)((fws1 << 8) | fws0);
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function reads firmware dnld offset registers
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param dat A pointer to keep returned data
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_read_fw_dnld_offset(mlan_adapter *pmadapter,
|
|
|
|
t_u32 *dat)
|
|
|
|
{
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
const mlan_sdio_card_reg *reg = pmadapter->pcard_sd->reg;
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u32 fw_dnld_offset_0 = 0;
|
|
|
|
t_u32 fw_dnld_offset_1 = 0;
|
|
|
|
t_u32 fw_dnld_offset_2 = 0;
|
|
|
|
t_u32 fw_dnld_offset_3 = 0;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
reg->fw_dnld_offset_0_reg, &fw_dnld_offset_0);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Dev fw_dnld_offset_0 reg read failed: reg(0x%04X)=0x%x. Terminating download\n",
|
|
|
|
reg->fw_dnld_offset_0_reg, fw_dnld_offset_0);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
reg->fw_dnld_offset_1_reg, &fw_dnld_offset_1);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Dev fw_dnld_offset_1 reg read failed: reg(0x%04X)=0x%x. Terminating download\n",
|
|
|
|
reg->fw_dnld_offset_1_reg, fw_dnld_offset_1);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
reg->fw_dnld_offset_2_reg, &fw_dnld_offset_2);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Dev fw_dnld_offset_2 reg read failed: reg(0x%04X)=0x%x. Terminating download\n",
|
|
|
|
reg->fw_dnld_offset_2_reg, fw_dnld_offset_2);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
reg->fw_dnld_offset_3_reg, &fw_dnld_offset_3);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Dev fw_dnld_offset_3 reg read failed: reg(0x%04X)=0x%x. Terminating download\n",
|
|
|
|
reg->fw_dnld_offset_3_reg, fw_dnld_offset_3);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dat = (t_u32)(((fw_dnld_offset_3 & 0xff) << 24) |
|
|
|
|
((fw_dnld_offset_2 & 0xff) << 16) |
|
|
|
|
((fw_dnld_offset_1 & 0xff) << 8) |
|
|
|
|
(fw_dnld_offset_0 & 0xff));
|
|
|
|
|
|
|
|
done:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function reads firmware dnld status registers
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param dat A pointer to keep returned data
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_read_fw_dnld_status(mlan_adapter *pmadapter,
|
|
|
|
t_u16 *dat)
|
|
|
|
{
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
const mlan_sdio_card_reg *reg = pmadapter->pcard_sd->reg;
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u32 fw_dnld_status_0 = 0;
|
|
|
|
t_u32 fw_dnld_status_1 = 0;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
reg->fw_dnld_status_0_reg, &fw_dnld_status_0);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Dev fw_dnld_status_0 reg read failed: reg(0x%04X)=0x%x. Terminating download\n",
|
|
|
|
reg->fw_dnld_status_0_reg, fw_dnld_status_0);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
reg->fw_dnld_status_1_reg, &fw_dnld_status_1);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Dev fw_dnld_status_1 reg read failed: reg(0x%04X)=0x%x. Terminating download\n",
|
|
|
|
reg->fw_dnld_status_1_reg, fw_dnld_status_1);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dat = (t_u16)(((fw_dnld_status_1 & 0xff) << 8) |
|
|
|
|
(fw_dnld_status_0 & 0xff));
|
|
|
|
|
|
|
|
done:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @brief This function disables the host interrupts mask.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param mask the interrupt mask
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_disable_host_int_mask(pmlan_adapter pmadapter,
|
|
|
|
t_u8 mask)
|
|
|
|
{
|
|
|
|
t_u32 host_int_mask = 0;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
/* Read back the host_int_mask register */
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pcard_sd->reg->host_int_mask_reg,
|
|
|
|
&host_int_mask)) {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update with the mask and write back to the register */
|
|
|
|
host_int_mask &= ~mask;
|
|
|
|
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pcard_sd->reg->host_int_mask_reg,
|
|
|
|
host_int_mask)) {
|
|
|
|
PRINTM(MWARN, "Disable host interrupt failed\n");
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function enables the host interrupts mask
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param mask the interrupt mask
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_enable_host_int_mask(pmlan_adapter pmadapter,
|
|
|
|
t_u8 mask)
|
|
|
|
{
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
/* Simply write the mask to the register */
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pcard_sd->reg->host_int_mask_reg,
|
|
|
|
mask)) {
|
|
|
|
PRINTM(MWARN, "Enable host interrupt failed\n");
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function reads data from the card.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param type A pointer to keep type as data or command
|
|
|
|
* @param nb A pointer to keep the data/cmd length returned in buffer
|
|
|
|
* @param pmbuf A pointer to the SDIO data/cmd buffer
|
|
|
|
* @param npayload the length of data/cmd buffer
|
|
|
|
* @param ioport the SDIO ioport
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_card_to_host(mlan_adapter *pmadapter, t_u32 *type,
|
|
|
|
t_u32 *nb, pmlan_buffer pmbuf,
|
|
|
|
t_u32 npayload, t_u32 ioport)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
t_u32 i = 0;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
if (!pmbuf) {
|
|
|
|
PRINTM(MWARN, "pmbuf is NULL!\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
do {
|
|
|
|
ret = pcb->moal_read_data_sync(pmadapter->pmoal_handle, pmbuf,
|
|
|
|
ioport, 0);
|
|
|
|
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"wlan: cmd53 read failed: %d ioport=0x%x retry=%d\n",
|
|
|
|
ret, ioport, i);
|
|
|
|
i++;
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG,
|
|
|
|
HOST_TERM_CMD53)) {
|
|
|
|
PRINTM(MERROR, "Set Term cmd53 failed\n");
|
|
|
|
}
|
|
|
|
if (i > MAX_WRITE_IOMEM_RETRY) {
|
|
|
|
pmbuf->status_code = MLAN_ERROR_DATA_RX_FAIL;
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (ret == MLAN_STATUS_FAILURE);
|
|
|
|
*nb = wlan_le16_to_cpu(*(t_u16 *)(pmbuf->pbuf + pmbuf->data_offset));
|
|
|
|
if (*nb > npayload) {
|
|
|
|
PRINTM(MERROR, "invalid packet, *nb=%d, npayload=%d\n", *nb,
|
|
|
|
npayload);
|
|
|
|
pmbuf->status_code = MLAN_ERROR_PKT_SIZE_INVALID;
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
DBG_HEXDUMP(MIF_D, "SDIO Blk Rd", pmbuf->pbuf + pmbuf->data_offset,
|
|
|
|
MIN(*nb, MAX_DATA_DUMP_LEN));
|
|
|
|
|
|
|
|
*type = wlan_le16_to_cpu(
|
|
|
|
*(t_u16 *)(pmbuf->pbuf + pmbuf->data_offset + 2));
|
|
|
|
|
|
|
|
exit:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function downloads FW blocks to device
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter
|
|
|
|
* @param firmware A pointer to firmware image
|
|
|
|
* @param firmwarelen firmware len
|
|
|
|
*
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_prog_fw_w_helper(pmlan_adapter pmadapter, t_u8 *fw,
|
|
|
|
t_u32 fw_len)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
t_u8 *firmware = fw;
|
|
|
|
t_u32 firmwarelen = fw_len;
|
|
|
|
t_u32 offset = 0;
|
|
|
|
t_u32 base0, base1;
|
|
|
|
t_void *tmpfwbuf = MNULL;
|
|
|
|
t_u32 tmpfwbufsz;
|
|
|
|
t_u8 *fwbuf;
|
|
|
|
mlan_buffer mbuf;
|
|
|
|
t_u16 len = 0;
|
|
|
|
t_u32 txlen = 0, tx_blocks = 0, tries = 0;
|
|
|
|
t_u32 i = 0;
|
|
|
|
const mlan_sdio_card_reg *reg = pmadapter->pcard_sd->reg;
|
|
|
|
t_u32 read_base_0_reg = reg->base_0_reg;
|
|
|
|
t_u32 read_base_1_reg = reg->base_1_reg;
|
|
|
|
#if defined(SD9098)
|
|
|
|
t_u32 rev_id_reg = 0;
|
|
|
|
t_u32 revision_id = 0;
|
|
|
|
#endif
|
|
|
|
t_u8 check_fw_status = MFALSE;
|
|
|
|
t_u16 fw_dnld_status = 0;
|
|
|
|
t_u32 fw_dnld_offset = 0;
|
|
|
|
t_u8 mic_retry = 0;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
if (!firmware && !pcb->moal_get_fw_data) {
|
|
|
|
PRINTM(MMSG, "No firmware image found! Terminating download\n");
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRINTM(MINFO, "WLAN: Downloading FW image (%d bytes)\n", firmwarelen);
|
|
|
|
|
|
|
|
tmpfwbufsz = ALIGN_SZ(WLAN_UPLD_SIZE, DMA_ALIGNMENT);
|
|
|
|
ret = pcb->moal_malloc(pmadapter->pmoal_handle, tmpfwbufsz,
|
|
|
|
MLAN_MEM_DEF | MLAN_MEM_DMA, (t_u8 **)&tmpfwbuf);
|
|
|
|
if ((ret != MLAN_STATUS_SUCCESS) || !tmpfwbuf) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Unable to allocate buffer for firmware. Terminating download\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
memset(pmadapter, tmpfwbuf, 0, tmpfwbufsz);
|
|
|
|
/* Ensure 8-byte aligned firmware buffer */
|
|
|
|
fwbuf = (t_u8 *)ALIGN_ADDR(tmpfwbuf, DMA_ALIGNMENT);
|
|
|
|
#if defined(SD9098)
|
|
|
|
if (IS_SD9098(pmadapter->card_type)) {
|
|
|
|
rev_id_reg = pmadapter->pcard_sd->reg->card_revision_reg;
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle, rev_id_reg,
|
|
|
|
&revision_id);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Card Revision register read failed:"
|
|
|
|
"card_revision_reg=0x%x\n",
|
|
|
|
rev_id_reg);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
/* Skyhawk A0, need to check both CRC and MIC error */
|
|
|
|
if (revision_id >= CHIP_9098_REV_A0)
|
|
|
|
check_fw_status = MTRUE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(SD9097)
|
|
|
|
if (IS_SD9097(pmadapter->card_type))
|
|
|
|
check_fw_status = MTRUE;
|
|
|
|
#endif
|
|
|
|
/* Perform firmware data transfer */
|
|
|
|
do {
|
|
|
|
/* The host polls for the DN_LD_CARD_RDY and CARD_IO_READY bits
|
|
|
|
*/
|
|
|
|
ret = wlan_sdio_poll_card_status(
|
|
|
|
pmadapter, CARD_IO_READY | DN_LD_CARD_RDY);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MFATAL,
|
|
|
|
"WLAN: FW download with helper poll status timeout @ %d\n",
|
|
|
|
offset);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* More data */
|
|
|
|
if (firmwarelen && offset >= firmwarelen)
|
|
|
|
break;
|
|
|
|
|
|
|
|
for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
read_base_0_reg, &base0);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Dev BASE0 register read failed:"
|
|
|
|
" base0=0x%04X(%d). Terminating download\n",
|
|
|
|
base0, base0);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
ret = pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
read_base_1_reg, &base1);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Dev BASE1 register read failed:"
|
|
|
|
" base1=0x%04X(%d). Terminating download\n",
|
|
|
|
base1, base1);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
len = (t_u16)(((base1 & 0xff) << 8) | (base0 & 0xff));
|
|
|
|
|
|
|
|
if (len)
|
|
|
|
break;
|
|
|
|
wlan_udelay(pmadapter, 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
break;
|
|
|
|
else if (len > WLAN_UPLD_SIZE) {
|
|
|
|
PRINTM(MFATAL,
|
|
|
|
"WLAN: FW download failure @ %d, invalid length %d\n",
|
|
|
|
offset, len);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ignore CRC check before download the 1st packet */
|
|
|
|
if (offset == 0 && (len & MBIT(0)))
|
|
|
|
len &= ~MBIT(0);
|
|
|
|
|
|
|
|
txlen = len;
|
|
|
|
|
|
|
|
if (len & MBIT(0)) {
|
|
|
|
/* New fw download process, check CRC and MIC error */
|
|
|
|
if (check_fw_status) {
|
|
|
|
/* Get offset from fw dnld offset Register */
|
|
|
|
ret = wlan_sdio_read_fw_dnld_offset(
|
|
|
|
pmadapter, &fw_dnld_offset);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MFATAL,
|
|
|
|
"WLAN: FW download with helper read fw dnld offset failed @ %d\n",
|
|
|
|
offset);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
/* Get CRC MIC error from fw dnld status
|
|
|
|
* Register */
|
|
|
|
ret = wlan_sdio_read_fw_dnld_status(
|
|
|
|
pmadapter, &fw_dnld_status);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MFATAL,
|
|
|
|
"WLAN: FW download with helper read fw dnld status failed @ %d\n",
|
|
|
|
offset);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"WLAN: FW download error: status=0x%x offset = 0x%x fw offset = 0x%x\n",
|
|
|
|
fw_dnld_status, offset, fw_dnld_offset);
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
if (i > MAX_WRITE_IOMEM_RETRY) {
|
|
|
|
PRINTM(MFATAL,
|
|
|
|
"WLAN: FW download failure @ %d, over max retry count\n",
|
|
|
|
offset);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"WLAN: FW CRC error indicated by the helper:"
|
|
|
|
" len = 0x%04X, txlen = %d\n",
|
|
|
|
len, txlen);
|
|
|
|
len &= ~MBIT(0);
|
|
|
|
if (fw_dnld_status & (MBIT(6) | MBIT(7))) {
|
|
|
|
offset = 0;
|
|
|
|
mic_retry++;
|
|
|
|
if (mic_retry > MAX_FW_RETRY) {
|
|
|
|
PRINTM(MFATAL,
|
|
|
|
"WLAN: FW download failure @ %d, over max mic retry count\n",
|
|
|
|
offset);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
PRINTM(MERROR, "WLAN: retry: %d, offset %d\n", i,
|
|
|
|
offset);
|
|
|
|
DBG_HEXDUMP(MERROR, "WLAN: FW block:", fwbuf, len);
|
|
|
|
/* Setting this to 0 to resend from same offset */
|
|
|
|
txlen = 0;
|
|
|
|
} else {
|
|
|
|
i = 0;
|
|
|
|
|
|
|
|
/* Set blocksize to transfer - checking
|
|
|
|
* for last block */
|
|
|
|
if (firmwarelen && firmwarelen - offset < txlen)
|
|
|
|
txlen = firmwarelen - offset;
|
|
|
|
PRINTM(MINFO, ".");
|
|
|
|
|
|
|
|
tx_blocks = (txlen + MLAN_SDIO_BLOCK_SIZE_FW_DNLD - 1) /
|
|
|
|
MLAN_SDIO_BLOCK_SIZE_FW_DNLD;
|
|
|
|
|
|
|
|
/* Copy payload to buffer */
|
|
|
|
if (firmware)
|
|
|
|
memmove(pmadapter, fwbuf, &firmware[offset],
|
|
|
|
txlen);
|
|
|
|
else
|
|
|
|
pcb->moal_get_fw_data(pmadapter->pmoal_handle,
|
|
|
|
offset, txlen, fwbuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send data */
|
|
|
|
memset(pmadapter, &mbuf, 0, sizeof(mlan_buffer));
|
|
|
|
mbuf.pbuf = (t_u8 *)fwbuf;
|
|
|
|
mbuf.data_len = tx_blocks * MLAN_SDIO_BLOCK_SIZE_FW_DNLD;
|
|
|
|
|
|
|
|
ret = pcb->moal_write_data_sync(pmadapter->pmoal_handle, &mbuf,
|
|
|
|
pmadapter->pcard_sd->ioport, 0);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"WLAN: FW download, write iomem (%d) failed @ %d\n",
|
|
|
|
i, offset);
|
|
|
|
if (pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG,
|
|
|
|
HOST_TERM_CMD53) !=
|
|
|
|
MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR, "write CFG reg failed\n");
|
|
|
|
}
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset += txlen;
|
|
|
|
} while (MTRUE);
|
|
|
|
|
|
|
|
PRINTM(MMSG, "Wlan: FW download over, firmwarelen=%d downloaded %d\n",
|
|
|
|
firmwarelen, offset);
|
|
|
|
|
|
|
|
ret = MLAN_STATUS_SUCCESS;
|
|
|
|
done:
|
|
|
|
if (tmpfwbuf)
|
|
|
|
pcb->moal_mfree(pmadapter->pmoal_handle, (t_u8 *)tmpfwbuf);
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function disables the host interrupts.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_disable_sdio_host_int(pmlan_adapter pmadapter)
|
|
|
|
{
|
|
|
|
mlan_status ret;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
ret = wlan_sdio_disable_host_int_mask(pmadapter, HIM_DISABLE);
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function decodes the rx packet &
|
|
|
|
* calls corresponding handlers according to the packet type
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pmbuf A pointer to the SDIO data/cmd buffer
|
|
|
|
* @param upld_typ Type of rx packet
|
|
|
|
* @param lock_flag flag for spin_lock.
|
|
|
|
* @return MLAN_STATUS_SUCCESS
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_decode_rx_packet(mlan_adapter *pmadapter,
|
|
|
|
mlan_buffer *pmbuf, t_u32 upld_typ,
|
|
|
|
t_u8 lock_flag)
|
|
|
|
{
|
|
|
|
t_u8 *cmd_buf;
|
|
|
|
t_u32 event;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
switch (upld_typ) {
|
|
|
|
case MLAN_TYPE_SPA_DATA:
|
|
|
|
PRINTM(MINFO, "--- Rx: SPA Data packet ---\n");
|
|
|
|
pmbuf->data_len = pmadapter->upld_len;
|
|
|
|
if (pmadapter->rx_work_flag) {
|
|
|
|
pmbuf->buf_type = MLAN_BUF_TYPE_SPA_DATA;
|
|
|
|
if (lock_flag)
|
|
|
|
pmadapter->callbacks.moal_spin_lock(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
pmadapter->rx_data_queue.plock);
|
|
|
|
util_enqueue_list_tail(pmadapter->pmoal_handle,
|
|
|
|
&pmadapter->rx_data_queue,
|
|
|
|
(pmlan_linked_list)pmbuf, MNULL,
|
|
|
|
MNULL);
|
|
|
|
pmadapter->rx_pkts_queued++;
|
|
|
|
if (lock_flag)
|
|
|
|
pmadapter->callbacks.moal_spin_unlock(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
pmadapter->rx_data_queue.plock);
|
|
|
|
} else {
|
|
|
|
wlan_decode_spa_buffer(pmadapter,
|
|
|
|
pmbuf->pbuf + pmbuf->data_offset,
|
|
|
|
pmbuf->data_len);
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
}
|
|
|
|
pmadapter->data_received = MTRUE;
|
|
|
|
break;
|
|
|
|
case MLAN_TYPE_DATA:
|
|
|
|
PRINTM(MINFO, "--- Rx: Data packet ---\n");
|
|
|
|
if (pmadapter->upld_len > pmbuf->data_len) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"SDIO: Drop packet upld_len=%d data_len=%d \n",
|
|
|
|
pmadapter->upld_len, pmbuf->data_len);
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pmbuf->data_len = (pmadapter->upld_len - SDIO_INTF_HEADER_LEN);
|
|
|
|
pmbuf->data_offset += SDIO_INTF_HEADER_LEN;
|
|
|
|
if (pmadapter->rx_work_flag) {
|
|
|
|
if (lock_flag)
|
|
|
|
pmadapter->callbacks.moal_spin_lock(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
pmadapter->rx_data_queue.plock);
|
|
|
|
util_enqueue_list_tail(pmadapter->pmoal_handle,
|
|
|
|
&pmadapter->rx_data_queue,
|
|
|
|
(pmlan_linked_list)pmbuf, MNULL,
|
|
|
|
MNULL);
|
|
|
|
pmadapter->rx_pkts_queued++;
|
|
|
|
if (lock_flag)
|
|
|
|
pmadapter->callbacks.moal_spin_unlock(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
pmadapter->rx_data_queue.plock);
|
|
|
|
} else {
|
|
|
|
wlan_handle_rx_packet(pmadapter, pmbuf);
|
|
|
|
}
|
|
|
|
pmadapter->data_received = MTRUE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MLAN_TYPE_CMD:
|
|
|
|
PRINTM(MINFO, "--- Rx: Cmd Response ---\n");
|
|
|
|
/* take care of curr_cmd = NULL case */
|
|
|
|
if (!pmadapter->curr_cmd) {
|
|
|
|
cmd_buf = pmadapter->upld_buf;
|
|
|
|
if (pmadapter->ps_state == PS_STATE_SLEEP_CFM) {
|
|
|
|
wlan_process_sleep_confirm_resp(
|
|
|
|
pmadapter,
|
|
|
|
pmbuf->pbuf + pmbuf->data_offset +
|
|
|
|
SDIO_INTF_HEADER_LEN,
|
|
|
|
pmadapter->upld_len -
|
|
|
|
SDIO_INTF_HEADER_LEN);
|
|
|
|
}
|
|
|
|
pmadapter->upld_len -= SDIO_INTF_HEADER_LEN;
|
|
|
|
memcpy_ext(pmadapter, cmd_buf,
|
|
|
|
pmbuf->pbuf + pmbuf->data_offset +
|
|
|
|
SDIO_INTF_HEADER_LEN,
|
|
|
|
pmadapter->upld_len - SDIO_INTF_HEADER_LEN,
|
|
|
|
MRVDRV_SIZE_OF_CMD_BUFFER);
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
} else {
|
|
|
|
pmadapter->cmd_resp_received = MTRUE;
|
|
|
|
pmadapter->upld_len -= SDIO_INTF_HEADER_LEN;
|
|
|
|
pmbuf->data_len = pmadapter->upld_len;
|
|
|
|
pmbuf->data_offset += SDIO_INTF_HEADER_LEN;
|
|
|
|
pmadapter->curr_cmd->respbuf = pmbuf;
|
|
|
|
if (pmadapter->upld_len >= MRVDRV_SIZE_OF_CMD_BUFFER) {
|
|
|
|
PRINTM(MMSG, "Invalid CmdResp len=%d\n",
|
|
|
|
pmadapter->upld_len);
|
|
|
|
DBG_HEXDUMP(MERROR, "Invalid CmdResp",
|
|
|
|
pmbuf->pbuf + pmbuf->data_offset,
|
|
|
|
MAX_DATA_DUMP_LEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MLAN_TYPE_EVENT:
|
|
|
|
PRINTM(MINFO, "--- Rx: Event ---\n");
|
|
|
|
event = *(t_u32 *)&pmbuf->pbuf[pmbuf->data_offset +
|
|
|
|
SDIO_INTF_HEADER_LEN];
|
|
|
|
pmadapter->event_cause = wlan_le32_to_cpu(event);
|
|
|
|
if ((pmadapter->upld_len > MLAN_EVENT_HEADER_LEN) &&
|
|
|
|
((pmadapter->upld_len - MLAN_EVENT_HEADER_LEN) <
|
|
|
|
MAX_EVENT_SIZE)) {
|
|
|
|
memcpy_ext(pmadapter, pmadapter->event_body,
|
|
|
|
pmbuf->pbuf + pmbuf->data_offset +
|
|
|
|
MLAN_EVENT_HEADER_LEN,
|
|
|
|
pmadapter->upld_len - MLAN_EVENT_HEADER_LEN,
|
|
|
|
MAX_EVENT_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* event cause has been saved to adapter->event_cause */
|
|
|
|
pmadapter->event_received = MTRUE;
|
|
|
|
pmbuf->data_len = pmadapter->upld_len;
|
|
|
|
pmadapter->pmlan_buffer_event = pmbuf;
|
|
|
|
|
|
|
|
/* remove SDIO header */
|
|
|
|
pmbuf->data_offset += SDIO_INTF_HEADER_LEN;
|
|
|
|
pmbuf->data_len -= SDIO_INTF_HEADER_LEN;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
PRINTM(MERROR, "SDIO unknown upload type = 0x%x\n", upld_typ);
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function receives single packet
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_receive_single_packet(mlan_adapter *pmadapter)
|
|
|
|
{
|
|
|
|
mlan_buffer *pmbuf;
|
|
|
|
t_u8 port;
|
|
|
|
t_u16 rx_len;
|
|
|
|
t_u32 pkt_type = 0;
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
pmbuf = pmadapter->pcard_sd->mpa_rx.mbuf_arr[0];
|
|
|
|
port = pmadapter->pcard_sd->mpa_rx.start_port;
|
|
|
|
rx_len = pmadapter->pcard_sd->mpa_rx.len_arr[0];
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
wlan_sdio_card_to_host(pmadapter, &pkt_type,
|
|
|
|
(t_u32 *)&pmadapter->upld_len, pmbuf, rx_len,
|
|
|
|
pmadapter->pcard_sd->ioport + port)) {
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (pkt_type != MLAN_TYPE_DATA && pkt_type != MLAN_TYPE_SPA_DATA) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"receive a wrong pkt from DATA PORT: type=%d, len=%dd\n",
|
|
|
|
pkt_type, pmbuf->data_len);
|
|
|
|
pmbuf->status_code = MLAN_ERROR_DATA_RX_FAIL;
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->mpa_rx_count[0]++;
|
|
|
|
wlan_decode_rx_packet(pmadapter, pmbuf, pkt_type, MTRUE);
|
|
|
|
done:
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
MP_RX_AGGR_BUF_RESET(pmadapter);
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function receives data from the card in aggregate mode.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_receive_mp_aggr_buf(mlan_adapter *pmadapter)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
mlan_buffer mbuf_aggr;
|
|
|
|
mlan_buffer *mbuf_deaggr;
|
|
|
|
t_u32 pind = 0;
|
|
|
|
t_u32 pkt_len, pkt_type = 0;
|
|
|
|
t_u8 *curr_ptr;
|
|
|
|
t_u32 cmd53_port = 0;
|
|
|
|
t_u32 i = 0;
|
|
|
|
t_u32 port_count = 0;
|
|
|
|
|
|
|
|
/* do aggr RX now */
|
|
|
|
PRINTM(MINFO, "do_rx_aggr: num of packets: %d\n",
|
|
|
|
pmadapter->pcard_sd->mpa_rx.pkt_cnt);
|
|
|
|
|
|
|
|
memset(pmadapter, &mbuf_aggr, 0, sizeof(mlan_buffer));
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->mpa_rx.pkt_cnt == 1)
|
|
|
|
return wlan_receive_single_packet(pmadapter);
|
|
|
|
if (!pmadapter->pcard_sd->mpa_rx.buf) {
|
|
|
|
mbuf_aggr.data_len = pmadapter->pcard_sd->mpa_rx.buf_len;
|
|
|
|
mbuf_aggr.pnext = mbuf_aggr.pprev = &mbuf_aggr;
|
|
|
|
mbuf_aggr.use_count = 0;
|
|
|
|
for (pind = 0; pind < pmadapter->pcard_sd->mpa_rx.pkt_cnt;
|
|
|
|
pind++) {
|
|
|
|
pmadapter->pcard_sd->mpa_rx.mbuf_arr[pind]->data_len =
|
|
|
|
pmadapter->pcard_sd->mpa_rx.len_arr[pind];
|
|
|
|
wlan_link_buf_to_aggr(
|
|
|
|
&mbuf_aggr,
|
|
|
|
pmadapter->pcard_sd->mpa_rx.mbuf_arr[pind]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mbuf_aggr.pbuf = (t_u8 *)pmadapter->pcard_sd->mpa_rx.buf;
|
|
|
|
mbuf_aggr.data_len = pmadapter->pcard_sd->mpa_rx.buf_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
port_count = bitcount(pmadapter->pcard_sd->mpa_rx.ports) - 1;
|
|
|
|
/* port_count = pmadapter->mpa_rx.pkt_cnt - 1; */
|
|
|
|
cmd53_port = (pmadapter->pcard_sd->ioport | SDIO_MPA_ADDR_BASE |
|
|
|
|
(port_count << 8)) +
|
|
|
|
pmadapter->pcard_sd->mpa_rx.start_port;
|
|
|
|
do {
|
|
|
|
ret = pcb->moal_read_data_sync(pmadapter->pmoal_handle,
|
|
|
|
&mbuf_aggr, cmd53_port, 0);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"wlan: sdio mp cmd53 read failed: %d ioport=0x%x retry=%d\n",
|
|
|
|
ret, cmd53_port, i);
|
|
|
|
i++;
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG,
|
|
|
|
HOST_TERM_CMD53)) {
|
|
|
|
PRINTM(MERROR, "Set Term cmd53 failed\n");
|
|
|
|
}
|
|
|
|
if (i > MAX_WRITE_IOMEM_RETRY) {
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (ret == MLAN_STATUS_FAILURE);
|
|
|
|
if (pmadapter->rx_work_flag)
|
|
|
|
pmadapter->callbacks.moal_spin_lock(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
pmadapter->rx_data_queue.plock);
|
|
|
|
if (!pmadapter->pcard_sd->mpa_rx.buf &&
|
|
|
|
pmadapter->pcard_sd->mpa_rx.pkt_cnt > 1) {
|
|
|
|
for (pind = 0; pind < pmadapter->pcard_sd->mpa_rx.pkt_cnt;
|
|
|
|
pind++) {
|
|
|
|
mbuf_deaggr =
|
|
|
|
pmadapter->pcard_sd->mpa_rx.mbuf_arr[pind];
|
|
|
|
pkt_len = wlan_le16_to_cpu(
|
|
|
|
*(t_u16 *)(mbuf_deaggr->pbuf +
|
|
|
|
mbuf_deaggr->data_offset));
|
|
|
|
pkt_type = wlan_le16_to_cpu(
|
|
|
|
*(t_u16 *)(mbuf_deaggr->pbuf +
|
|
|
|
mbuf_deaggr->data_offset + 2));
|
|
|
|
pmadapter->upld_len = pkt_len;
|
|
|
|
wlan_decode_rx_packet(pmadapter, mbuf_deaggr, pkt_type,
|
|
|
|
MFALSE);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
DBG_HEXDUMP(MIF_D, "SDIO MP-A Blk Rd",
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf,
|
|
|
|
MIN(pmadapter->pcard_sd->mpa_rx.buf_len,
|
|
|
|
MAX_DATA_DUMP_LEN));
|
|
|
|
|
|
|
|
curr_ptr = pmadapter->pcard_sd->mpa_rx.buf;
|
|
|
|
|
|
|
|
for (pind = 0; pind < pmadapter->pcard_sd->mpa_rx.pkt_cnt;
|
|
|
|
pind++) {
|
|
|
|
/* get curr PKT len & type */
|
|
|
|
pkt_len = wlan_le16_to_cpu(*(t_u16 *)&curr_ptr[0]);
|
|
|
|
pkt_type = wlan_le16_to_cpu(*(t_u16 *)&curr_ptr[2]);
|
|
|
|
|
|
|
|
PRINTM(MINFO, "RX: [%d] pktlen: %d pkt_type: 0x%x\n",
|
|
|
|
pind, pkt_len, pkt_type);
|
|
|
|
|
|
|
|
/* copy pkt to deaggr buf */
|
|
|
|
mbuf_deaggr =
|
|
|
|
pmadapter->pcard_sd->mpa_rx.mbuf_arr[pind];
|
|
|
|
if ((pkt_type == MLAN_TYPE_DATA ||
|
|
|
|
pkt_type == MLAN_TYPE_SPA_DATA) &&
|
|
|
|
(pkt_len <=
|
|
|
|
pmadapter->pcard_sd->mpa_rx.len_arr[pind])) {
|
|
|
|
memcpy_ext(pmadapter,
|
|
|
|
mbuf_deaggr->pbuf +
|
|
|
|
mbuf_deaggr->data_offset,
|
|
|
|
curr_ptr, pkt_len, pkt_len);
|
|
|
|
pmadapter->upld_len = pkt_len;
|
|
|
|
/* Process de-aggr packet */
|
|
|
|
wlan_decode_rx_packet(pmadapter, mbuf_deaggr,
|
|
|
|
pkt_type, MFALSE);
|
|
|
|
} else {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Wrong aggr packet: type=%d, len=%d, max_len=%d\n",
|
|
|
|
pkt_type, pkt_len,
|
|
|
|
pmadapter->pcard_sd->mpa_rx
|
|
|
|
.len_arr[pind]);
|
|
|
|
wlan_free_mlan_buffer(pmadapter, mbuf_deaggr);
|
|
|
|
}
|
|
|
|
curr_ptr += pmadapter->pcard_sd->mpa_rx.len_arr[pind];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pmadapter->rx_work_flag)
|
|
|
|
pmadapter->callbacks.moal_spin_unlock(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
pmadapter->rx_data_queue.plock);
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->mpa_rx_count[pmadapter->pcard_sd->mpa_rx.pkt_cnt - 1]++;
|
|
|
|
MP_RX_AGGR_BUF_RESET(pmadapter);
|
|
|
|
done:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function receives data from the card in aggregate mode.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pmbuf A pointer to the SDIO data/cmd buffer
|
|
|
|
* @param port Current port on which packet needs to be rxed
|
|
|
|
* @param rx_len Length of received packet
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_card_to_host_mp_aggr(mlan_adapter *pmadapter,
|
|
|
|
mlan_buffer *pmbuf, t_u8 port,
|
|
|
|
t_u16 rx_len)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_s32 f_do_rx_aggr = 0;
|
|
|
|
t_s32 f_do_rx_cur = 0;
|
|
|
|
t_s32 f_aggr_cur = 0;
|
|
|
|
t_s32 f_post_aggr_cur = 0;
|
|
|
|
t_u32 pind = 0;
|
|
|
|
t_u32 pkt_type = 0;
|
|
|
|
const mlan_sdio_card_reg *reg = pmadapter->pcard_sd->reg;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
if (!pmadapter->pcard_sd->mpa_rx.enabled) {
|
|
|
|
PRINTM(MINFO,
|
|
|
|
"card_2_host_mp_aggr: rx aggregation disabled !\n");
|
|
|
|
|
|
|
|
f_do_rx_cur = 1;
|
|
|
|
goto rx_curr_single;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->mp_rd_bitmap & reg->data_port_mask) {
|
|
|
|
/* Some more data RX pending */
|
|
|
|
PRINTM(MINFO, "card_2_host_mp_aggr: Not last packet\n");
|
|
|
|
|
|
|
|
if (MP_RX_AGGR_IN_PROGRESS(pmadapter)) {
|
|
|
|
if (MP_RX_AGGR_BUF_HAS_ROOM(pmadapter, rx_len)) {
|
|
|
|
f_aggr_cur = 1;
|
|
|
|
} else {
|
|
|
|
/* No room in Aggr buf, do rx aggr now */
|
|
|
|
f_do_rx_aggr = 1;
|
|
|
|
f_post_aggr_cur = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Rx aggr not in progress */
|
|
|
|
f_aggr_cur = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* No more data RX pending */
|
|
|
|
PRINTM(MINFO, "card_2_host_mp_aggr: Last packet\n");
|
|
|
|
|
|
|
|
if (MP_RX_AGGR_IN_PROGRESS(pmadapter)) {
|
|
|
|
f_do_rx_aggr = 1;
|
|
|
|
if (MP_RX_AGGR_BUF_HAS_ROOM(pmadapter, rx_len)) {
|
|
|
|
f_aggr_cur = 1;
|
|
|
|
} else {
|
|
|
|
/* No room in Aggr buf, do rx aggr now */
|
|
|
|
f_do_rx_cur = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
f_do_rx_cur = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f_aggr_cur) {
|
|
|
|
PRINTM(MINFO, "Current packet aggregation.\n");
|
|
|
|
/* Curr pkt can be aggregated */
|
|
|
|
MP_RX_AGGR_SETUP(pmadapter, pmbuf, port, rx_len);
|
|
|
|
|
|
|
|
if (MP_RX_AGGR_PKT_LIMIT_REACHED(pmadapter) ||
|
|
|
|
MP_RX_AGGR_PORT_LIMIT_REACHED(pmadapter)) {
|
|
|
|
PRINTM(MINFO,
|
|
|
|
"card_2_host_mp_aggr: Aggregation Packet limit reached\n");
|
|
|
|
/* No more pkts allowed in Aggr buf, rx it */
|
|
|
|
f_do_rx_aggr = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f_do_rx_aggr) {
|
|
|
|
/* do aggr RX now */
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
wlan_receive_mp_aggr_buf(pmadapter)) {
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rx_curr_single:
|
|
|
|
if (f_do_rx_cur) {
|
|
|
|
PRINTM(MINFO, "RX: f_do_rx_cur: port: %d rx_len: %d\n", port,
|
|
|
|
rx_len);
|
|
|
|
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
wlan_sdio_card_to_host(
|
|
|
|
pmadapter, &pkt_type, (t_u32 *)&pmadapter->upld_len,
|
|
|
|
pmbuf, rx_len,
|
|
|
|
pmadapter->pcard_sd->ioport + port)) {
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (pkt_type != MLAN_TYPE_DATA &&
|
|
|
|
pkt_type != MLAN_TYPE_SPA_DATA) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"receive a wrong pkt from DATA PORT: type=%d, len=%dd\n",
|
|
|
|
pkt_type, pmbuf->data_len);
|
|
|
|
pmbuf->status_code = MLAN_ERROR_DATA_RX_FAIL;
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
pmadapter->pcard_sd->mpa_rx_count[0]++;
|
|
|
|
|
|
|
|
wlan_decode_rx_packet(pmadapter, pmbuf, pkt_type, MTRUE);
|
|
|
|
}
|
|
|
|
if (f_post_aggr_cur) {
|
|
|
|
PRINTM(MINFO, "Current packet aggregation.\n");
|
|
|
|
/* Curr pkt can be aggregated */
|
|
|
|
MP_RX_AGGR_SETUP(pmadapter, pmbuf, port, rx_len);
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
if (ret == MLAN_STATUS_FAILURE) {
|
|
|
|
if (MP_RX_AGGR_IN_PROGRESS(pmadapter)) {
|
|
|
|
/* MP-A transfer failed - cleanup */
|
|
|
|
for (pind = 0;
|
|
|
|
pind < pmadapter->pcard_sd->mpa_rx.pkt_cnt;
|
|
|
|
pind++) {
|
|
|
|
wlan_free_mlan_buffer(
|
|
|
|
pmadapter, pmadapter->pcard_sd->mpa_rx
|
|
|
|
.mbuf_arr[pind]);
|
|
|
|
}
|
|
|
|
MP_RX_AGGR_BUF_RESET(pmadapter);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f_do_rx_cur) {
|
|
|
|
/* Single Transfer pending */
|
|
|
|
/* Free curr buff also */
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function sends aggr buf
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_send_mp_aggr_buf(mlan_adapter *pmadapter)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u32 cmd53_port = 0;
|
|
|
|
t_u32 port_count = 0;
|
|
|
|
mlan_buffer mbuf_aggr;
|
|
|
|
t_u8 i = 0;
|
|
|
|
t_u8 mp_aggr_pkt_limit = SDIO_MP_AGGR_DEF_PKT_LIMIT;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
if (!pmadapter->pcard_sd->mpa_tx.pkt_cnt) {
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
PRINTM(MINFO,
|
|
|
|
"host_2_card_mp_aggr: Send aggregation buffer."
|
|
|
|
"%d %d\n",
|
|
|
|
pmadapter->pcard_sd->mpa_tx.start_port,
|
|
|
|
pmadapter->pcard_sd->mpa_tx.ports);
|
|
|
|
|
|
|
|
memset(pmadapter, &mbuf_aggr, 0, sizeof(mlan_buffer));
|
|
|
|
|
|
|
|
if (!pmadapter->pcard_sd->mpa_tx.buf &&
|
|
|
|
pmadapter->pcard_sd->mpa_tx.pkt_cnt > 1) {
|
|
|
|
mbuf_aggr.data_len = pmadapter->pcard_sd->mpa_tx.buf_len;
|
|
|
|
mbuf_aggr.pnext = mbuf_aggr.pprev = &mbuf_aggr;
|
|
|
|
mbuf_aggr.use_count = 0;
|
|
|
|
for (i = 0; i < pmadapter->pcard_sd->mpa_tx.pkt_cnt; i++)
|
|
|
|
wlan_link_buf_to_aggr(
|
|
|
|
&mbuf_aggr,
|
|
|
|
pmadapter->pcard_sd->mpa_tx.mbuf_arr[i]);
|
|
|
|
} else {
|
|
|
|
mbuf_aggr.pbuf = (t_u8 *)pmadapter->pcard_sd->mpa_tx.buf;
|
|
|
|
mbuf_aggr.data_len = pmadapter->pcard_sd->mpa_tx.buf_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
port_count = bitcount(pmadapter->pcard_sd->mpa_tx.ports) - 1;
|
|
|
|
cmd53_port = (pmadapter->pcard_sd->ioport | SDIO_MPA_ADDR_BASE |
|
|
|
|
(port_count << 8)) +
|
|
|
|
pmadapter->pcard_sd->mpa_tx.start_port;
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->mpa_tx.pkt_cnt == 1)
|
|
|
|
cmd53_port = pmadapter->pcard_sd->ioport +
|
|
|
|
pmadapter->pcard_sd->mpa_tx.start_port;
|
|
|
|
/** only one packet */
|
|
|
|
if (!pmadapter->pcard_sd->mpa_tx.buf &&
|
|
|
|
pmadapter->pcard_sd->mpa_tx.pkt_cnt == 1)
|
|
|
|
ret = wlan_write_data_sync(
|
|
|
|
pmadapter, pmadapter->pcard_sd->mpa_tx.mbuf_arr[0],
|
|
|
|
cmd53_port);
|
|
|
|
else
|
|
|
|
ret = wlan_write_data_sync(pmadapter, &mbuf_aggr, cmd53_port);
|
|
|
|
if (!pmadapter->pcard_sd->mpa_tx.buf) {
|
|
|
|
/** free mlan buffer */
|
|
|
|
for (i = 0; i < pmadapter->pcard_sd->mpa_tx.pkt_cnt; i++) {
|
|
|
|
wlan_write_data_complete(
|
|
|
|
pmadapter,
|
|
|
|
pmadapter->pcard_sd->mpa_tx.mbuf_arr[i],
|
|
|
|
MLAN_STATUS_SUCCESS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!(pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
(1 << pmadapter->pcard_sd->curr_wr_port)) &&
|
|
|
|
(pmadapter->pcard_sd->mpa_tx.pkt_cnt < mp_aggr_pkt_limit))
|
|
|
|
pmadapter->pcard_sd->mpa_sent_no_ports++;
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->mpa_tx_count[pmadapter->pcard_sd->mpa_tx.pkt_cnt - 1]++;
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->last_mp_wr_bitmap[pmadapter->pcard_sd->last_mp_index] =
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap;
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->last_mp_wr_ports[pmadapter->pcard_sd->last_mp_index] =
|
|
|
|
cmd53_port;
|
|
|
|
pmadapter->pcard_sd->last_mp_wr_len[pmadapter->pcard_sd->last_mp_index] =
|
|
|
|
pmadapter->pcard_sd->mpa_tx.buf_len;
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->last_curr_wr_port[pmadapter->pcard_sd->last_mp_index] =
|
|
|
|
pmadapter->pcard_sd->curr_wr_port;
|
|
|
|
memcpy_ext(
|
|
|
|
pmadapter,
|
|
|
|
(t_u8 *)&pmadapter->pcard_sd
|
|
|
|
->last_mp_wr_info[pmadapter->pcard_sd->last_mp_index *
|
|
|
|
mp_aggr_pkt_limit],
|
|
|
|
(t_u8 *)pmadapter->pcard_sd->mpa_tx.mp_wr_info,
|
|
|
|
mp_aggr_pkt_limit * sizeof(t_u16),
|
|
|
|
mp_aggr_pkt_limit * sizeof(t_u16));
|
|
|
|
pmadapter->pcard_sd->last_mp_index++;
|
|
|
|
if (pmadapter->pcard_sd->last_mp_index >= SDIO_MP_DBG_NUM)
|
|
|
|
pmadapter->pcard_sd->last_mp_index = 0;
|
|
|
|
MP_TX_AGGR_BUF_RESET(pmadapter);
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function sends data to the card in SDIO aggregated mode.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param mbuf A pointer to the SDIO data/cmd buffer
|
|
|
|
* @param port current port for aggregation
|
|
|
|
* @param next_pkt_len Length of next packet used for multiport aggregation
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_host_to_card_mp_aggr(mlan_adapter *pmadapter,
|
|
|
|
mlan_buffer *mbuf, t_u8 port,
|
|
|
|
t_u32 next_pkt_len)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_s32 f_send_aggr_buf = 0;
|
|
|
|
t_s32 f_send_cur_buf = 0;
|
|
|
|
t_s32 f_precopy_cur_buf = 0;
|
|
|
|
t_s32 f_postcopy_cur_buf = 0;
|
|
|
|
t_u8 aggr_sg = 0;
|
|
|
|
t_u8 mp_aggr_pkt_limit = SDIO_MP_AGGR_DEF_PKT_LIMIT;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
PRINTM(MIF_D, "host_2_card_mp_aggr: next_pkt_len: %d curr_port:%d\n",
|
|
|
|
next_pkt_len, port);
|
|
|
|
|
|
|
|
if (!pmadapter->pcard_sd->mpa_tx.enabled) {
|
|
|
|
PRINTM(MINFO,
|
|
|
|
"host_2_card_mp_aggr: tx aggregation disabled !\n");
|
|
|
|
f_send_cur_buf = 1;
|
|
|
|
goto tx_curr_single;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_pkt_len) {
|
|
|
|
/* More pkt in TX queue */
|
|
|
|
PRINTM(MINFO, "host_2_card_mp_aggr: More packets in Queue.\n");
|
|
|
|
|
|
|
|
if (MP_TX_AGGR_IN_PROGRESS(pmadapter)) {
|
|
|
|
if (MP_TX_AGGR_BUF_HAS_ROOM(pmadapter, mbuf,
|
|
|
|
mbuf->data_len)) {
|
|
|
|
f_precopy_cur_buf = 1;
|
|
|
|
|
|
|
|
if (!(pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
(1
|
|
|
|
<< pmadapter->pcard_sd->curr_wr_port)) ||
|
|
|
|
!MP_TX_AGGR_BUF_HAS_ROOM(
|
|
|
|
pmadapter, mbuf,
|
|
|
|
mbuf->data_len + next_pkt_len)) {
|
|
|
|
f_send_aggr_buf = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* No room in Aggr buf, send it */
|
|
|
|
f_send_aggr_buf = 1;
|
|
|
|
|
|
|
|
if (!(pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
(1
|
|
|
|
<< pmadapter->pcard_sd->curr_wr_port))) {
|
|
|
|
f_send_cur_buf = 1;
|
|
|
|
} else {
|
|
|
|
f_postcopy_cur_buf = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (MP_TX_AGGR_BUF_HAS_ROOM(pmadapter, mbuf,
|
|
|
|
mbuf->data_len) &&
|
|
|
|
(pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
(1 << pmadapter->pcard_sd->curr_wr_port)))
|
|
|
|
f_precopy_cur_buf = 1;
|
|
|
|
else
|
|
|
|
f_send_cur_buf = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Last pkt in TX queue */
|
|
|
|
PRINTM(MINFO,
|
|
|
|
"host_2_card_mp_aggr: Last packet in Tx Queue.\n");
|
|
|
|
|
|
|
|
if (MP_TX_AGGR_IN_PROGRESS(pmadapter)) {
|
|
|
|
/* some packs in Aggr buf already */
|
|
|
|
f_send_aggr_buf = 1;
|
|
|
|
|
|
|
|
if (MP_TX_AGGR_BUF_HAS_ROOM(pmadapter, mbuf,
|
|
|
|
mbuf->data_len)) {
|
|
|
|
f_precopy_cur_buf = 1;
|
|
|
|
} else {
|
|
|
|
/* No room in Aggr buf, send it */
|
|
|
|
f_send_cur_buf = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
f_send_cur_buf = 1;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->mpa_sent_last_pkt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f_precopy_cur_buf) {
|
|
|
|
PRINTM(MINFO, "host_2_card_mp_aggr: Precopy current buffer\n");
|
|
|
|
if (pmadapter->pcard_sd->mpa_buf)
|
|
|
|
memcpy_ext(
|
|
|
|
pmadapter,
|
|
|
|
pmadapter->pcard_sd->mpa_buf +
|
|
|
|
(pmadapter->pcard_sd->last_mp_index *
|
|
|
|
mp_aggr_pkt_limit +
|
|
|
|
pmadapter->pcard_sd->mpa_tx.pkt_cnt) *
|
|
|
|
MLAN_SDIO_BLOCK_SIZE,
|
|
|
|
mbuf->pbuf + mbuf->data_offset,
|
|
|
|
MLAN_SDIO_BLOCK_SIZE, MLAN_SDIO_BLOCK_SIZE);
|
|
|
|
if (!pmadapter->pcard_sd->mpa_tx.buf) {
|
|
|
|
MP_TX_AGGR_BUF_PUT_SG(pmadapter, mbuf, port);
|
|
|
|
aggr_sg = MTRUE;
|
|
|
|
} else {
|
|
|
|
MP_TX_AGGR_BUF_PUT(pmadapter, mbuf, port);
|
|
|
|
}
|
|
|
|
if (MP_TX_AGGR_PKT_LIMIT_REACHED(pmadapter)) {
|
|
|
|
PRINTM(MIF_D,
|
|
|
|
"host_2_card_mp_aggr: Aggregation Pkt limit reached\n");
|
|
|
|
/* No more pkts allowed in Aggr buf, send it */
|
|
|
|
f_send_aggr_buf = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f_send_aggr_buf)
|
|
|
|
ret = wlan_send_mp_aggr_buf(pmadapter);
|
|
|
|
|
|
|
|
tx_curr_single:
|
|
|
|
if (f_send_cur_buf) {
|
|
|
|
PRINTM(MINFO, "host_2_card_mp_aggr: writing to port #%d\n",
|
|
|
|
port);
|
|
|
|
ret = wlan_write_data_sync(pmadapter, mbuf,
|
|
|
|
pmadapter->pcard_sd->ioport + port);
|
|
|
|
if (!(pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
(1 << pmadapter->pcard_sd->curr_wr_port)))
|
|
|
|
pmadapter->pcard_sd->mpa_sent_no_ports++;
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->last_mp_wr_bitmap[pmadapter->pcard_sd->last_mp_index] =
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap;
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->last_mp_wr_ports[pmadapter->pcard_sd->last_mp_index] =
|
|
|
|
pmadapter->pcard_sd->ioport + port;
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->last_mp_wr_len[pmadapter->pcard_sd->last_mp_index] =
|
|
|
|
mbuf->data_len;
|
|
|
|
memset(pmadapter,
|
|
|
|
(t_u8 *)&pmadapter->pcard_sd->last_mp_wr_info
|
|
|
|
[pmadapter->pcard_sd->last_mp_index *
|
|
|
|
mp_aggr_pkt_limit],
|
|
|
|
0, sizeof(t_u16) * mp_aggr_pkt_limit);
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->last_mp_wr_info[pmadapter->pcard_sd->last_mp_index *
|
|
|
|
mp_aggr_pkt_limit] =
|
|
|
|
*(t_u16 *)(mbuf->pbuf + mbuf->data_offset);
|
|
|
|
pmadapter->pcard_sd
|
|
|
|
->last_curr_wr_port[pmadapter->pcard_sd->last_mp_index] =
|
|
|
|
pmadapter->pcard_sd->curr_wr_port;
|
|
|
|
if (pmadapter->pcard_sd->mpa_buf)
|
|
|
|
memcpy_ext(pmadapter,
|
|
|
|
pmadapter->pcard_sd->mpa_buf +
|
|
|
|
(pmadapter->pcard_sd->last_mp_index *
|
|
|
|
mp_aggr_pkt_limit *
|
|
|
|
MLAN_SDIO_BLOCK_SIZE),
|
|
|
|
mbuf->pbuf + mbuf->data_offset,
|
|
|
|
MLAN_SDIO_BLOCK_SIZE, MLAN_SDIO_BLOCK_SIZE);
|
|
|
|
pmadapter->pcard_sd->last_mp_index++;
|
|
|
|
if (pmadapter->pcard_sd->last_mp_index >= SDIO_MP_DBG_NUM)
|
|
|
|
pmadapter->pcard_sd->last_mp_index = 0;
|
|
|
|
pmadapter->pcard_sd->mpa_tx_count[0]++;
|
|
|
|
}
|
|
|
|
if (f_postcopy_cur_buf) {
|
|
|
|
PRINTM(MINFO, "host_2_card_mp_aggr: Postcopy current buffer\n");
|
|
|
|
if (pmadapter->pcard_sd->mpa_buf)
|
|
|
|
memcpy_ext(
|
|
|
|
pmadapter,
|
|
|
|
pmadapter->pcard_sd->mpa_buf +
|
|
|
|
(pmadapter->pcard_sd->last_mp_index *
|
|
|
|
mp_aggr_pkt_limit +
|
|
|
|
pmadapter->pcard_sd->mpa_tx.pkt_cnt) *
|
|
|
|
MLAN_SDIO_BLOCK_SIZE,
|
|
|
|
mbuf->pbuf + mbuf->data_offset,
|
|
|
|
MLAN_SDIO_BLOCK_SIZE, MLAN_SDIO_BLOCK_SIZE);
|
|
|
|
if (!pmadapter->pcard_sd->mpa_tx.buf) {
|
|
|
|
MP_TX_AGGR_BUF_PUT_SG(pmadapter, mbuf, port);
|
|
|
|
aggr_sg = MTRUE;
|
|
|
|
} else {
|
|
|
|
MP_TX_AGGR_BUF_PUT(pmadapter, mbuf, port);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Always return PENDING in SG mode */
|
|
|
|
if (aggr_sg)
|
|
|
|
ret = MLAN_STATUS_PENDING;
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/********************************************************
|
|
|
|
Global functions
|
|
|
|
********************************************************/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function checks if the interface is ready to download
|
|
|
|
* or not while other download interface is present
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param val Winner status (0: winner)
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_check_winner_status(mlan_adapter *pmadapter, t_u32 *val)
|
|
|
|
{
|
|
|
|
t_u32 winner = 0;
|
|
|
|
pmlan_callbacks pcb;
|
|
|
|
t_u8 card_winner_check_reg = pmadapter->pcard_sd->reg->winner_check_reg;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
pcb = &pmadapter->callbacks;
|
|
|
|
|
|
|
|
if (MLAN_STATUS_SUCCESS != pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
card_winner_check_reg,
|
|
|
|
&winner)) {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
*val = winner;
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function checks if the firmware is ready to accept
|
|
|
|
* command or not.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pollnum Maximum polling number
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_check_fw_status(mlan_adapter *pmadapter, t_u32 pollnum)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u16 firmwarestat = 0;
|
|
|
|
t_u32 tries;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
/* Wait for firmware initialization event */
|
|
|
|
for (tries = 0; tries < pollnum; tries++) {
|
|
|
|
ret = wlan_sdio_read_fw_status(pmadapter, &firmwarestat);
|
|
|
|
if (MLAN_STATUS_SUCCESS != ret)
|
|
|
|
continue;
|
|
|
|
if (firmwarestat == SDIO_FIRMWARE_READY) {
|
|
|
|
ret = MLAN_STATUS_SUCCESS;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
wlan_mdelay(pmadapter, 100);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
if (pollnum > 1)
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Fail to poll firmware status: firmwarestat=0x%x\n",
|
|
|
|
firmwarestat);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function enables the host interrupts.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_enable_sdio_host_int(pmlan_adapter pmadapter)
|
|
|
|
{
|
|
|
|
mlan_status ret;
|
|
|
|
t_u8 mask = pmadapter->pcard_sd->reg->host_int_enable;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
ret = wlan_sdio_enable_host_int_mask(pmadapter, mask);
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_dnld_fw(pmlan_adapter pmadapter, pmlan_fw_image pmfw)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u32 poll_num = 1;
|
|
|
|
t_u32 winner = 0;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
/*when using GPIO wakeup, don't run the below code.
|
|
|
|
*if using GPIO wakeup, host will do handshake with FW
|
|
|
|
*to check if FW wake up and pull up SDIO line, then reload driver.
|
|
|
|
*So when using GPIO wakeup, don't need driver to do check wakeup status
|
|
|
|
*again. when using SDIO interface wakeup, run the below code; if using
|
|
|
|
*SDIO interface wakeup, driver need to do check wakeup status with FW.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Card specific probing */
|
|
|
|
ret = wlan_sdio_probe(pmadapter);
|
|
|
|
if (ret == MLAN_STATUS_FAILURE) {
|
|
|
|
PRINTM(MERROR, "WLAN SDIO probe failed\n", ret);
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if firmware is already running */
|
|
|
|
ret = wlan_sdio_check_fw_status(pmadapter, poll_num);
|
|
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
|
|
#if defined(SDIO)
|
|
|
|
if (pmfw->fw_reload == FW_RELOAD_SDIO_INBAND_RESET) {
|
|
|
|
PRINTM(MMSG, "Try reset fw in mlan\n");
|
|
|
|
ret = wlan_reset_fw(pmadapter);
|
|
|
|
if (ret == MLAN_STATUS_FAILURE) {
|
|
|
|
PRINTM(MERROR, "FW reset failure!");
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
#endif
|
|
|
|
PRINTM(MMSG,
|
|
|
|
"WLAN FW already running! Skip FW download\n");
|
|
|
|
#if defined(SDIO)
|
|
|
|
pmadapter->ops.wakeup_card(pmadapter, MFALSE);
|
|
|
|
#endif
|
|
|
|
goto done;
|
|
|
|
#if defined(SDIO)
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
poll_num = MAX_FIRMWARE_POLL_TRIES;
|
|
|
|
|
|
|
|
/* Check if other interface is downloading */
|
|
|
|
ret = wlan_sdio_check_winner_status(pmadapter, &winner);
|
|
|
|
if (ret == MLAN_STATUS_FAILURE) {
|
|
|
|
PRINTM(MFATAL, "WLAN read winner status failed!\n");
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (winner) {
|
|
|
|
PRINTM(MMSG,
|
|
|
|
"WLAN is not the winner (0x%x). Skip FW download\n",
|
|
|
|
winner);
|
|
|
|
poll_num = MAX_MULTI_INTERFACE_POLL_TRIES;
|
|
|
|
goto poll_fw;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Download the firmware image via helper */
|
|
|
|
ret = wlan_sdio_prog_fw_w_helper(pmadapter, pmfw->pfw_buf,
|
|
|
|
pmfw->fw_len);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR, "wlan_dnld_fw fail ret=0x%x\n", ret);
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
poll_fw:
|
|
|
|
/* Check if the firmware is downloaded successfully or not */
|
|
|
|
ret = wlan_sdio_check_fw_status(pmadapter, poll_num);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MFATAL, "FW failed to be active in time!\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
|
|
|
|
/* re-enable host interrupt for mlan after fw dnld is successful */
|
|
|
|
wlan_enable_sdio_host_int(pmadapter);
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function probes the driver
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_probe(pmlan_adapter pmadapter)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u32 sdio_ireg = 0;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
/*
|
|
|
|
* Read the HOST_INT_STATUS_REG for ACK the first interrupt got
|
|
|
|
* from the bootloader. If we don't do this we get a interrupt
|
|
|
|
* as soon as we register the irq.
|
|
|
|
*/
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pcard_sd->reg->host_int_status_reg,
|
|
|
|
&sdio_ireg);
|
|
|
|
|
|
|
|
/* Disable host interrupt mask register for SDIO */
|
|
|
|
ret = wlan_disable_sdio_host_int(pmadapter);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
/* Get SDIO ioport */
|
|
|
|
ret = wlan_sdio_init_ioport(pmadapter);
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function get sdio device from card type
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_get_sdio_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_sdio_card),
|
|
|
|
MLAN_MEM_DEF,
|
|
|
|
(t_u8 **)&pmadapter->pcard_sd);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS || !pmadapter->pcard_sd) {
|
|
|
|
PRINTM(MERROR, "Failed to allocate pcard_sd\n");
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (card_type) {
|
|
|
|
#ifdef SD8887
|
|
|
|
case CARD_TYPE_SD8887:
|
|
|
|
pmadapter->pcard_sd->reg = &mlan_reg_sd8887;
|
|
|
|
pmadapter->pcard_info = &mlan_card_info_sd8887;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef SD8897
|
|
|
|
case CARD_TYPE_SD8897:
|
|
|
|
pmadapter->pcard_sd->reg = &mlan_reg_sd8897;
|
|
|
|
pmadapter->pcard_info = &mlan_card_info_sd8897;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if defined(SD8977) || defined(SD8978)
|
|
|
|
case CARD_TYPE_SD8977:
|
|
|
|
case CARD_TYPE_SD8978:
|
|
|
|
pmadapter->pcard_sd->reg = &mlan_reg_sd8977_sd8997;
|
|
|
|
pmadapter->pcard_info = &mlan_card_info_sd8977;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef SD8997
|
|
|
|
case CARD_TYPE_SD8997:
|
|
|
|
pmadapter->pcard_sd->reg = &mlan_reg_sd8977_sd8997;
|
|
|
|
pmadapter->pcard_info = &mlan_card_info_sd8997;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef SD8987
|
|
|
|
case CARD_TYPE_SD8987:
|
|
|
|
pmadapter->pcard_sd->reg = &mlan_reg_sd8977_sd8997;
|
|
|
|
pmadapter->pcard_info = &mlan_card_info_sd8987;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef SD9098
|
|
|
|
case CARD_TYPE_SD9098:
|
|
|
|
pmadapter->pcard_sd->reg = &mlan_reg_sd8977_sd8997;
|
|
|
|
pmadapter->pcard_info = &mlan_card_info_sd9098;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef SD9097
|
|
|
|
case CARD_TYPE_SD9097:
|
|
|
|
pmadapter->pcard_sd->reg = &mlan_reg_sd8977_sd8997;
|
|
|
|
pmadapter->pcard_info = &mlan_card_info_sd9097;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
PRINTM(MERROR, "can't get right card type \n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function gets interrupt status.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_interrupt(t_u16 msg_id, pmlan_adapter pmadapter)
|
|
|
|
{
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
mlan_buffer mbuf;
|
|
|
|
t_u32 sdio_ireg = 0;
|
|
|
|
t_u8 offset = 0;
|
|
|
|
t_u8 max_mp_regs = pmadapter->pcard_sd->reg->max_mp_regs;
|
|
|
|
t_u8 host_int_status_reg =
|
|
|
|
pmadapter->pcard_sd->reg->host_int_status_reg;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
while (max_mp_regs) {
|
|
|
|
memset(pmadapter, &mbuf, 0, sizeof(mlan_buffer));
|
|
|
|
mbuf.pbuf = pmadapter->pcard_sd->mp_regs + offset;
|
|
|
|
mbuf.data_len = MIN(max_mp_regs, MLAN_SDIO_BLOCK_SIZE);
|
|
|
|
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
pcb->moal_read_data_sync(pmadapter->pmoal_handle, &mbuf,
|
|
|
|
(REG_PORT + offset) |
|
|
|
|
MLAN_SDIO_BYTE_MODE_MASK,
|
|
|
|
0)) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"moal_read_data_sync: read registers failed\n");
|
|
|
|
pmadapter->dbg.num_int_read_failure++;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
offset += mbuf.data_len;
|
|
|
|
max_mp_regs -= mbuf.data_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
DBG_HEXDUMP(MIF_D, "SDIO MP Registers", pmadapter->pcard_sd->mp_regs,
|
|
|
|
max_mp_regs);
|
|
|
|
sdio_ireg = pmadapter->pcard_sd->mp_regs[host_int_status_reg];
|
|
|
|
pmadapter->dbg.last_int_status = pmadapter->ireg | sdio_ireg;
|
|
|
|
if (sdio_ireg) {
|
|
|
|
/*
|
|
|
|
* DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS
|
|
|
|
* DN_LD_CMD_PORT_HOST_INT_STATUS and/or
|
|
|
|
* UP_LD_CMD_PORT_HOST_INT_STATUS
|
|
|
|
* Clear the interrupt status register
|
|
|
|
*/
|
|
|
|
PRINTM(MINTR, "wlan_interrupt: sdio_ireg = 0x%x\n", sdio_ireg);
|
|
|
|
pmadapter->pcard_sd->num_of_irq++;
|
|
|
|
pcb->moal_spin_lock(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pint_lock);
|
|
|
|
pmadapter->ireg |= sdio_ireg;
|
|
|
|
pcb->moal_spin_unlock(pmadapter->pmoal_handle,
|
|
|
|
pmadapter->pint_lock);
|
|
|
|
if (!pmadapter->pps_uapsd_mode &&
|
|
|
|
pmadapter->ps_state == PS_STATE_SLEEP) {
|
|
|
|
pmadapter->pm_wakeup_fw_try = MFALSE;
|
|
|
|
pmadapter->ps_state = PS_STATE_AWAKE;
|
|
|
|
pmadapter->pm_wakeup_card_req = MFALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
PRINTM(MMSG, "wlan_interrupt: sdio_ireg = 0x%x\n", sdio_ireg);
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function try to read the packet when fail to alloc rx buffer
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param port Current port on which packet needs to be rxed
|
|
|
|
* @param rx_len Length of received packet
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
static mlan_status wlan_sdio_card_to_host_recovery(mlan_adapter *pmadapter,
|
|
|
|
t_u8 port, t_u16 rx_len)
|
|
|
|
{
|
|
|
|
mlan_buffer mbuf;
|
|
|
|
t_u32 pkt_type = 0;
|
|
|
|
mlan_status ret = MLAN_STATUS_FAILURE;
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
if (MP_RX_AGGR_IN_PROGRESS(pmadapter)) {
|
|
|
|
PRINTM(MDATA, "Recovery:do Rx Aggr\n");
|
|
|
|
/* do aggr RX now */
|
|
|
|
wlan_receive_mp_aggr_buf(pmadapter);
|
|
|
|
}
|
|
|
|
memset(pmadapter, &mbuf, 0, sizeof(mlan_buffer));
|
|
|
|
mbuf.pbuf = pmadapter->pcard_sd->rx_buf;
|
|
|
|
mbuf.data_len = rx_len;
|
|
|
|
|
|
|
|
PRINTM(MDATA, "Recovery: Try read port=%d rx_len=%d\n", port, rx_len);
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
wlan_sdio_card_to_host(pmadapter, &pkt_type,
|
|
|
|
(t_u32 *)&pmadapter->upld_len, &mbuf, rx_len,
|
|
|
|
pmadapter->pcard_sd->ioport + port)) {
|
|
|
|
PRINTM(MERROR, "Recovery: Fail to do cmd53\n");
|
|
|
|
}
|
|
|
|
if (pkt_type != MLAN_TYPE_DATA && pkt_type != MLAN_TYPE_SPA_DATA) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Recovery: Receive a wrong pkt: type=%d, len=%d\n",
|
|
|
|
pkt_type, pmadapter->upld_len);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (pkt_type == MLAN_TYPE_DATA) {
|
|
|
|
// TODO fill the hole in Rx reorder table
|
|
|
|
PRINTM(MDATA, "Recovery: Drop Data packet\n");
|
|
|
|
pmadapter->dbg.num_pkt_dropped++;
|
|
|
|
} else if (pkt_type == MLAN_TYPE_SPA_DATA) {
|
|
|
|
PRINTM(MDATA, "Recovery: SPA Data packet len=%d\n",
|
|
|
|
pmadapter->upld_len);
|
|
|
|
wlan_decode_spa_buffer(pmadapter, pmadapter->pcard_sd->rx_buf,
|
|
|
|
pmadapter->upld_len);
|
|
|
|
pmadapter->data_received = MTRUE;
|
|
|
|
}
|
|
|
|
PRINTM(MMSG, "wlan: Success handle rx port=%d, rx_len=%d \n", port,
|
|
|
|
rx_len);
|
|
|
|
ret = MLAN_STATUS_SUCCESS;
|
|
|
|
done:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function checks the interrupt status and handle it accordingly.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_process_sdio_int_status(mlan_adapter *pmadapter)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
t_u8 sdio_ireg;
|
|
|
|
mlan_buffer *pmbuf = MNULL;
|
|
|
|
|
|
|
|
t_u8 port = 0;
|
|
|
|
t_u32 len_reg_l, len_reg_u;
|
|
|
|
t_u32 rx_blocks;
|
|
|
|
t_u8 bit_count = 0;
|
|
|
|
t_u32 ps_state = pmadapter->ps_state;
|
|
|
|
t_u16 rx_len;
|
|
|
|
t_u32 upld_typ = 0;
|
|
|
|
t_u32 cr = 0;
|
|
|
|
const mlan_sdio_card_reg *reg = pmadapter->pcard_sd->reg;
|
|
|
|
t_u8 rd_len_p0_l = reg->rd_len_p0_l;
|
|
|
|
t_u8 rd_len_p0_u = reg->rd_len_p0_u;
|
|
|
|
t_u8 cmd_rd_len_0 = reg->cmd_rd_len_0;
|
|
|
|
t_u8 cmd_rd_len_1 = reg->cmd_rd_len_1;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
pcb->moal_spin_lock(pmadapter->pmoal_handle, pmadapter->pint_lock);
|
|
|
|
sdio_ireg = (t_u8)pmadapter->ireg;
|
|
|
|
pmadapter->ireg = 0;
|
|
|
|
pcb->moal_spin_unlock(pmadapter->pmoal_handle, pmadapter->pint_lock);
|
|
|
|
|
|
|
|
if (!sdio_ireg)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* check the command port */
|
|
|
|
if (sdio_ireg & DN_LD_CMD_PORT_HOST_INT_STATUS) {
|
|
|
|
if (pmadapter->cmd_sent)
|
|
|
|
pmadapter->cmd_sent = MFALSE;
|
|
|
|
|
|
|
|
PRINTM(MINFO, "cmd_sent=%d\n", pmadapter->cmd_sent);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sdio_ireg & UP_LD_CMD_PORT_HOST_INT_STATUS) {
|
|
|
|
/* read the len of control packet */
|
|
|
|
rx_len = ((t_u16)pmadapter->pcard_sd->mp_regs[cmd_rd_len_1])
|
|
|
|
<< 8;
|
|
|
|
rx_len |= (t_u16)pmadapter->pcard_sd->mp_regs[cmd_rd_len_0];
|
|
|
|
PRINTM(MINFO, "RX: cmd port rx_len=%u\n", rx_len);
|
|
|
|
rx_blocks = (rx_len + MLAN_SDIO_BLOCK_SIZE - 1) /
|
|
|
|
MLAN_SDIO_BLOCK_SIZE;
|
|
|
|
if (rx_len <= SDIO_INTF_HEADER_LEN ||
|
|
|
|
(rx_blocks * MLAN_SDIO_BLOCK_SIZE) > ALLOC_BUF_SIZE) {
|
|
|
|
PRINTM(MERROR, "invalid rx_len=%d\n", rx_len);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
rx_len = (t_u16)(rx_blocks * MLAN_SDIO_BLOCK_SIZE);
|
|
|
|
pmbuf = wlan_alloc_mlan_buffer(pmadapter, rx_len, 0,
|
|
|
|
MOAL_MALLOC_BUFFER);
|
|
|
|
if (pmbuf == MNULL) {
|
|
|
|
PRINTM(MERROR, "Failed to allocate 'mlan_buffer'\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
PRINTM(MINFO, "cmd rx buffer rx_len = %d\n", rx_len);
|
|
|
|
|
|
|
|
/* Transfer data from card */
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
wlan_sdio_card_to_host(
|
|
|
|
pmadapter, &upld_typ, (t_u32 *)&pmadapter->upld_len,
|
|
|
|
pmbuf, rx_len,
|
|
|
|
pmadapter->pcard_sd->ioport | CMD_PORT_SLCT)) {
|
|
|
|
pmadapter->dbg.num_cmdevt_card_to_host_failure++;
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Card-to-host cmd failed: int status=0x%x\n",
|
|
|
|
sdio_ireg);
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto term_cmd53;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((upld_typ != MLAN_TYPE_CMD) &&
|
|
|
|
(upld_typ != MLAN_TYPE_EVENT))
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"receive a wrong packet from CMD PORT. type =0x%x\n",
|
|
|
|
upld_typ);
|
|
|
|
|
|
|
|
wlan_decode_rx_packet(pmadapter, pmbuf, upld_typ, MFALSE);
|
|
|
|
|
|
|
|
/* We might receive data/sleep_cfm at the same time */
|
|
|
|
/* reset data_receive flag to avoid ps_state change */
|
|
|
|
if ((ps_state == PS_STATE_SLEEP_CFM) &&
|
|
|
|
(pmadapter->ps_state == PS_STATE_SLEEP))
|
|
|
|
pmadapter->data_received = MFALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sdio_ireg & DN_LD_HOST_INT_STATUS) {
|
|
|
|
if (pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
pmadapter->pcard_sd->mp_data_port_mask)
|
|
|
|
pmadapter->pcard_sd->mp_invalid_update++;
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap =
|
|
|
|
(t_u32)pmadapter->pcard_sd->mp_regs[reg->wr_bitmap_l];
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap |=
|
|
|
|
((t_u32)pmadapter->pcard_sd->mp_regs[reg->wr_bitmap_u])
|
|
|
|
<< 8;
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap |=
|
|
|
|
((t_u32)pmadapter->pcard_sd->mp_regs[reg->wr_bitmap_1l])
|
|
|
|
<< 16;
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap |=
|
|
|
|
((t_u32)pmadapter->pcard_sd->mp_regs[reg->wr_bitmap_1u])
|
|
|
|
<< 24;
|
|
|
|
bit_count = bitcount(pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
pmadapter->pcard_sd->mp_data_port_mask);
|
|
|
|
if (bit_count) {
|
|
|
|
pmadapter->pcard_sd->mp_update[bit_count - 1]++;
|
|
|
|
if (pmadapter->pcard_sd->mp_update[bit_count - 1] ==
|
|
|
|
0xffffffff)
|
|
|
|
memset(pmadapter,
|
|
|
|
pmadapter->pcard_sd->mp_update, 0,
|
|
|
|
sizeof(pmadapter->pcard_sd->mp_update));
|
|
|
|
}
|
|
|
|
|
|
|
|
pmadapter->pcard_sd->last_recv_wr_bitmap =
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap;
|
|
|
|
PRINTM(MINTR, "DNLD: wr_bitmap=0x%08x\n",
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap);
|
|
|
|
if (pmadapter->data_sent &&
|
|
|
|
(pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
(1 << pmadapter->pcard_sd->curr_wr_port))) {
|
|
|
|
PRINTM(MINFO, " <--- Tx DONE Interrupt --->\n");
|
|
|
|
pmadapter->data_sent = MFALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sdio_ireg & UP_LD_HOST_INT_STATUS) {
|
|
|
|
pmadapter->pcard_sd->mp_rd_bitmap =
|
|
|
|
(t_u32)pmadapter->pcard_sd->mp_regs[reg->rd_bitmap_l];
|
|
|
|
pmadapter->pcard_sd->mp_rd_bitmap |=
|
|
|
|
((t_u32)pmadapter->pcard_sd->mp_regs[reg->rd_bitmap_u])
|
|
|
|
<< 8;
|
|
|
|
pmadapter->pcard_sd->mp_rd_bitmap |=
|
|
|
|
((t_u32)pmadapter->pcard_sd->mp_regs[reg->rd_bitmap_1l])
|
|
|
|
<< 16;
|
|
|
|
pmadapter->pcard_sd->mp_rd_bitmap |=
|
|
|
|
((t_u32)pmadapter->pcard_sd->mp_regs[reg->rd_bitmap_1u])
|
|
|
|
<< 24;
|
|
|
|
PRINTM(MINTR, "UPLD: rd_bitmap=0x%08x\n",
|
|
|
|
pmadapter->pcard_sd->mp_rd_bitmap);
|
|
|
|
|
|
|
|
while (MTRUE) {
|
|
|
|
ret = wlan_get_rd_port(pmadapter, &port);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MINFO,
|
|
|
|
"no more rd_port to be handled\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
len_reg_l = rd_len_p0_l + (port << 1);
|
|
|
|
len_reg_u = rd_len_p0_u + (port << 1);
|
|
|
|
rx_len =
|
|
|
|
((t_u16)pmadapter->pcard_sd->mp_regs[len_reg_u])
|
|
|
|
<< 8;
|
|
|
|
rx_len |=
|
|
|
|
(t_u16)pmadapter->pcard_sd->mp_regs[len_reg_l];
|
|
|
|
PRINTM(MINFO, "RX: port=%d rx_len=%u\n", port, rx_len);
|
|
|
|
rx_blocks = (rx_len + MLAN_SDIO_BLOCK_SIZE - 1) /
|
|
|
|
MLAN_SDIO_BLOCK_SIZE;
|
|
|
|
if (rx_len <= SDIO_INTF_HEADER_LEN ||
|
|
|
|
(rx_blocks * MLAN_SDIO_BLOCK_SIZE) >
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf_size) {
|
|
|
|
PRINTM(MERROR, "invalid rx_len=%d\n", rx_len);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
rx_len = (t_u16)(rx_blocks * MLAN_SDIO_BLOCK_SIZE);
|
|
|
|
if (rx_len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE)
|
|
|
|
pmbuf = wlan_alloc_mlan_buffer(
|
|
|
|
pmadapter, rx_len, 0,
|
|
|
|
MOAL_MALLOC_BUFFER);
|
|
|
|
else
|
|
|
|
pmbuf = wlan_alloc_mlan_buffer(
|
|
|
|
pmadapter, rx_len, MLAN_RX_HEADER_LEN,
|
|
|
|
MOAL_ALLOC_MLAN_BUFFER);
|
|
|
|
if (pmbuf == MNULL) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Failed to allocate 'mlan_buffer'\n");
|
|
|
|
pmadapter->dbg.num_alloc_buffer_failure++;
|
|
|
|
if (MLAN_STATUS_SUCCESS ==
|
|
|
|
wlan_sdio_card_to_host_recovery(
|
|
|
|
pmadapter, port, rx_len))
|
|
|
|
continue;
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
PRINTM(MINFO, "rx_len = %d\n", rx_len);
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
|
|
wlan_sdio_card_to_host_mp_aggr(pmadapter, pmbuf,
|
|
|
|
port, rx_len)) {
|
|
|
|
pmadapter->dbg.num_rx_card_to_host_failure++;
|
|
|
|
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Card to host failed: int status=0x%x\n",
|
|
|
|
sdio_ireg);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto term_cmd53;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* We might receive data/sleep_cfm at the same time */
|
|
|
|
/* reset data_receive flag to avoid ps_state change */
|
|
|
|
if ((ps_state == PS_STATE_SLEEP_CFM) &&
|
|
|
|
(pmadapter->ps_state == PS_STATE_SLEEP))
|
|
|
|
pmadapter->data_received = MFALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = MLAN_STATUS_SUCCESS;
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
term_cmd53:
|
|
|
|
/* terminate cmd53 */
|
|
|
|
if (MLAN_STATUS_SUCCESS != pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG,
|
|
|
|
&cr))
|
|
|
|
PRINTM(MERROR, "read CFG reg failed\n");
|
|
|
|
PRINTM(MINFO, "Config Reg val = %d\n", cr);
|
|
|
|
if (MLAN_STATUS_SUCCESS != pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG,
|
|
|
|
(cr | HOST_TERM_CMD53)))
|
|
|
|
PRINTM(MERROR, "write CFG reg failed\n");
|
|
|
|
PRINTM(MINFO, "write success\n");
|
|
|
|
if (MLAN_STATUS_SUCCESS != pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG,
|
|
|
|
&cr))
|
|
|
|
PRINTM(MERROR, "read CFG reg failed\n");
|
|
|
|
PRINTM(MINFO, "Config reg val =%x\n", cr);
|
|
|
|
|
|
|
|
done:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function sends data to the card.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param type data or command
|
|
|
|
* @param pmbuf A pointer to mlan_buffer (pmbuf->data_len should include
|
|
|
|
* SDIO header)
|
|
|
|
* @param tx_param A pointer to mlan_tx_param
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_host_to_card(mlan_adapter *pmadapter, t_u8 type,
|
|
|
|
mlan_buffer *pmbuf, mlan_tx_param *tx_param)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u32 buf_block_len;
|
|
|
|
t_u32 blksz;
|
|
|
|
t_u8 port = 0;
|
|
|
|
t_u32 cmd53_port = 0;
|
|
|
|
t_u8 *payload = pmbuf->pbuf + pmbuf->data_offset;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
/* Allocate buffer and copy payload */
|
|
|
|
blksz = MLAN_SDIO_BLOCK_SIZE;
|
|
|
|
buf_block_len = (pmbuf->data_len + blksz - 1) / blksz;
|
|
|
|
*(t_u16 *)&payload[0] = wlan_cpu_to_le16((t_u16)pmbuf->data_len);
|
|
|
|
*(t_u16 *)&payload[2] = wlan_cpu_to_le16(type);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is SDIO specific header
|
|
|
|
* t_u16 length,
|
|
|
|
* t_u16 type (MLAN_TYPE_DATA = 0,
|
|
|
|
* MLAN_TYPE_CMD = 1, MLAN_TYPE_EVENT = 3)
|
|
|
|
*/
|
|
|
|
if (type == MLAN_TYPE_DATA) {
|
|
|
|
ret = wlan_get_wr_port_data(pmadapter, &port);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"no wr_port available: wr_bitmap=0x%08x curr_wr_port=%d\n",
|
|
|
|
pmadapter->pcard_sd->mp_wr_bitmap,
|
|
|
|
pmadapter->pcard_sd->curr_wr_port);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
/* Transfer data to card */
|
|
|
|
pmbuf->data_len = buf_block_len * blksz;
|
|
|
|
|
|
|
|
if (tx_param)
|
|
|
|
ret = wlan_host_to_card_mp_aggr(pmadapter, pmbuf, port,
|
|
|
|
tx_param->next_pkt_len);
|
|
|
|
else
|
|
|
|
ret = wlan_host_to_card_mp_aggr(pmadapter, pmbuf, port,
|
|
|
|
0);
|
|
|
|
} else {
|
|
|
|
/*Type must be MLAN_TYPE_CMD*/
|
|
|
|
pmadapter->cmd_sent = MTRUE;
|
|
|
|
if (pmbuf->data_len <= SDIO_INTF_HEADER_LEN ||
|
|
|
|
pmbuf->data_len > WLAN_UPLD_SIZE)
|
|
|
|
PRINTM(MWARN,
|
|
|
|
"wlan_sdio_host_to_card(): Error: payload=%p, nb=%d\n",
|
|
|
|
payload, pmbuf->data_len);
|
|
|
|
/* Transfer data to card */
|
|
|
|
pmbuf->data_len = buf_block_len * blksz;
|
|
|
|
cmd53_port = (pmadapter->pcard_sd->ioport) | CMD_PORT_SLCT;
|
|
|
|
ret = wlan_write_data_sync(pmadapter, pmbuf, cmd53_port);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == MLAN_STATUS_FAILURE) {
|
|
|
|
PRINTM(MERROR, "Error: host_to_card failed: 0x%X\n", ret);
|
|
|
|
if (type == MLAN_TYPE_CMD)
|
|
|
|
pmadapter->cmd_sent = MFALSE;
|
|
|
|
if (type == MLAN_TYPE_DATA)
|
|
|
|
pmadapter->data_sent = MFALSE;
|
|
|
|
} else {
|
|
|
|
if (type == MLAN_TYPE_DATA) {
|
|
|
|
if (!(pmadapter->pcard_sd->mp_wr_bitmap &
|
|
|
|
(1 << pmadapter->pcard_sd->curr_wr_port)))
|
|
|
|
pmadapter->data_sent = MTRUE;
|
|
|
|
else
|
|
|
|
pmadapter->data_sent = MFALSE;
|
|
|
|
}
|
|
|
|
DBG_HEXDUMP(MIF_D, "SDIO Blk Wr",
|
|
|
|
pmbuf->pbuf + pmbuf->data_offset,
|
|
|
|
MIN(pmbuf->data_len, MAX_DATA_DUMP_LEN));
|
|
|
|
}
|
|
|
|
exit:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if (defined(SD9098) || defined(SD9097))
|
|
|
|
/**
|
|
|
|
* @brief This function sends vdll data to the card.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pmbuf A pointer to mlan_buffer (pmbuf->data_len should include
|
|
|
|
* SDIO header)
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_send_vdll(mlan_adapter *pmadapter, mlan_buffer *pmbuf)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u32 buf_block_len;
|
|
|
|
t_u32 blksz;
|
|
|
|
t_u8 *payload = pmbuf->pbuf + pmbuf->data_offset;
|
|
|
|
t_u32 cmd53_port = 0;
|
|
|
|
ENTER();
|
|
|
|
blksz = MLAN_SDIO_BLOCK_SIZE;
|
|
|
|
buf_block_len = (pmbuf->data_len + blksz - 1) / blksz;
|
|
|
|
|
|
|
|
*(t_u16 *)&payload[0] = wlan_cpu_to_le16((t_u16)pmbuf->data_len);
|
|
|
|
*(t_u16 *)&payload[2] = wlan_cpu_to_le16(MLAN_TYPE_VDLL);
|
|
|
|
|
|
|
|
pmbuf->data_len = buf_block_len * blksz;
|
|
|
|
|
|
|
|
if (pmbuf->data_len > MRVDRV_SIZE_OF_CMD_BUFFER) {
|
|
|
|
PRINTM(MERROR, "VDLL block is too big: %d\n", pmbuf->data_len);
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
cmd53_port = (pmadapter->pcard_sd->ioport) | CMD_PORT_SLCT;
|
|
|
|
pmadapter->cmd_sent = MTRUE;
|
|
|
|
ret = wlan_write_data_sync(pmadapter, pmbuf, cmd53_port);
|
|
|
|
if (ret == MLAN_STATUS_FAILURE)
|
|
|
|
PRINTM(MERROR, "Send Vdll: host_to_card failed: 0x%X\n", ret);
|
|
|
|
else
|
|
|
|
DBG_HEXDUMP(MIF_D, "SDIO Blk Wr",
|
|
|
|
pmbuf->pbuf + pmbuf->data_offset,
|
|
|
|
MIN(pmbuf->data_len, MAX_DATA_DUMP_LEN));
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function sends data to the card.
|
|
|
|
*
|
|
|
|
* @param pmpriv A pointer to mlan_private structure
|
|
|
|
* @param type data or command
|
|
|
|
* @param pmbuf A pointer to mlan_buffer (pmbuf->data_len should include
|
|
|
|
* SDIO header)
|
|
|
|
* @param tx_param A pointer to mlan_tx_param
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_host_to_card_ext(pmlan_private pmpriv, t_u8 type,
|
|
|
|
mlan_buffer *pmbuf,
|
|
|
|
mlan_tx_param *tx_param)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
mlan_adapter *pmadapter = pmpriv->adapter;
|
|
|
|
|
|
|
|
#if (defined(SD9098) || defined(SD9097))
|
|
|
|
if (type == MLAN_TYPE_VDLL)
|
|
|
|
return wlan_sdio_send_vdll(pmadapter, pmbuf);
|
|
|
|
#endif
|
|
|
|
ret = wlan_sdio_host_to_card(pmadapter, type, pmbuf, tx_param);
|
|
|
|
|
|
|
|
if (type == MLAN_TYPE_DATA && ret == MLAN_STATUS_FAILURE)
|
|
|
|
pmadapter->data_sent = MFALSE;
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief Deaggregate single port aggregation packet
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param buf A pointer to aggregated data packet
|
|
|
|
* @param len
|
|
|
|
*
|
|
|
|
* @return N/A
|
|
|
|
*/
|
|
|
|
void wlan_decode_spa_buffer(mlan_adapter *pmadapter, t_u8 *buf, t_u32 len)
|
|
|
|
{
|
|
|
|
int total_pkt_len;
|
|
|
|
t_u8 block_num = 0;
|
|
|
|
t_u16 block_size = 0;
|
|
|
|
t_u8 *data;
|
|
|
|
t_u32 pkt_len, pkt_type = 0;
|
|
|
|
mlan_buffer *mbuf_deaggr = MNULL;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
data = (t_u8 *)buf;
|
|
|
|
total_pkt_len = len;
|
|
|
|
if (total_pkt_len < pmadapter->pcard_sd->sdio_rx_block_size) {
|
|
|
|
PRINTM(MERROR, "Invalid sp aggr packet size=%d\n",
|
|
|
|
total_pkt_len);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
while (total_pkt_len >=
|
|
|
|
(OFFSET_OF_SDIO_HEADER + SDIO_INTF_HEADER_LEN)) {
|
|
|
|
block_num = *(data + OFFSET_OF_BLOCK_NUMBER);
|
|
|
|
block_size =
|
|
|
|
pmadapter->pcard_sd->sdio_rx_block_size * block_num;
|
|
|
|
if (block_size > total_pkt_len) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Error in pkt, block_num=%d, pkt_len=%d\n",
|
|
|
|
block_num, total_pkt_len);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pkt_len = wlan_le16_to_cpu(
|
|
|
|
*(t_u16 *)(data + OFFSET_OF_SDIO_HEADER));
|
|
|
|
pkt_type = wlan_le16_to_cpu(
|
|
|
|
*(t_u16 *)(data + OFFSET_OF_SDIO_HEADER + 2));
|
|
|
|
if ((pkt_len + OFFSET_OF_SDIO_HEADER) > block_size) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Error in pkt, pkt_len=%d, block_size=%d\n",
|
|
|
|
pkt_len, block_size);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mbuf_deaggr = wlan_alloc_mlan_buffer(
|
|
|
|
pmadapter, pkt_len - SDIO_INTF_HEADER_LEN,
|
|
|
|
MLAN_RX_HEADER_LEN, MOAL_ALLOC_MLAN_BUFFER);
|
|
|
|
if (mbuf_deaggr == MNULL) {
|
|
|
|
PRINTM(MERROR, "Error allocating daggr mlan_buffer\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
memcpy_ext(pmadapter,
|
|
|
|
mbuf_deaggr->pbuf + mbuf_deaggr->data_offset,
|
|
|
|
data + OFFSET_OF_SDIO_HEADER + SDIO_INTF_HEADER_LEN,
|
|
|
|
pkt_len - SDIO_INTF_HEADER_LEN,
|
|
|
|
pkt_len - SDIO_INTF_HEADER_LEN);
|
|
|
|
mbuf_deaggr->data_len = pkt_len - SDIO_INTF_HEADER_LEN;
|
|
|
|
wlan_handle_rx_packet(pmadapter, mbuf_deaggr);
|
|
|
|
data += block_size;
|
|
|
|
total_pkt_len -= block_size;
|
|
|
|
if (total_pkt_len < pmadapter->pcard_sd->sdio_rx_block_size)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
LEAVE();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function deaggr rx pkt
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pmbuf A pointer to the SDIO mpa data
|
|
|
|
* @return N/A
|
|
|
|
*/
|
|
|
|
t_void wlan_sdio_deaggr_rx_pkt(pmlan_adapter pmadapter, mlan_buffer *pmbuf)
|
|
|
|
{
|
|
|
|
if (pmbuf->buf_type == MLAN_BUF_TYPE_SPA_DATA) {
|
|
|
|
wlan_decode_spa_buffer(pmadapter,
|
|
|
|
pmbuf->pbuf + pmbuf->data_offset,
|
|
|
|
pmbuf->data_len);
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
} else
|
|
|
|
wlan_handle_rx_packet(pmadapter, pmbuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function allocates buffer for the SDIO aggregation buffer
|
|
|
|
* related members of adapter structure
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param mpa_tx_buf_size Tx buffer size to allocate
|
|
|
|
* @param mpa_rx_buf_size Rx buffer size to allocate
|
|
|
|
*
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_alloc_sdio_mpa_buffers(mlan_adapter *pmadapter,
|
|
|
|
t_u32 mpa_tx_buf_size,
|
|
|
|
t_u32 mpa_rx_buf_size)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
t_u8 mp_aggr_pkt_limit = SDIO_MP_AGGR_DEF_PKT_LIMIT;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
if ((pmadapter->pcard_sd->max_segs < mp_aggr_pkt_limit) ||
|
|
|
|
(pmadapter->pcard_sd->max_seg_size <
|
|
|
|
pmadapter->pcard_sd->max_sp_tx_size)) {
|
|
|
|
ret = pcb->moal_malloc(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
mpa_tx_buf_size + DMA_ALIGNMENT,
|
|
|
|
MLAN_MEM_DEF | MLAN_MEM_DMA,
|
|
|
|
(t_u8 **)&pmadapter->pcard_sd->mpa_tx.head_ptr);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS ||
|
|
|
|
!pmadapter->pcard_sd->mpa_tx.head_ptr) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Could not allocate buffer for SDIO MP TX aggr\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->mpa_tx.buf = (t_u8 *)ALIGN_ADDR(
|
|
|
|
pmadapter->pcard_sd->mpa_tx.head_ptr, DMA_ALIGNMENT);
|
|
|
|
} else {
|
|
|
|
PRINTM(MMSG, "wlan: Enable TX SG mode\n");
|
|
|
|
pmadapter->pcard_sd->mpa_tx.head_ptr = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_tx.buf = MNULL;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->mpa_tx.buf_size = mpa_tx_buf_size;
|
|
|
|
|
|
|
|
if ((pmadapter->pcard_sd->max_segs < mp_aggr_pkt_limit) ||
|
|
|
|
(pmadapter->pcard_sd->max_seg_size <
|
|
|
|
pmadapter->pcard_sd->max_sp_rx_size)) {
|
|
|
|
ret = pcb->moal_malloc(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
mpa_rx_buf_size + DMA_ALIGNMENT,
|
|
|
|
MLAN_MEM_DEF | MLAN_MEM_DMA,
|
|
|
|
(t_u8 **)&pmadapter->pcard_sd->mpa_rx.head_ptr);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS ||
|
|
|
|
!pmadapter->pcard_sd->mpa_rx.head_ptr) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Could not allocate buffer for SDIO MP RX aggr\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf = (t_u8 *)ALIGN_ADDR(
|
|
|
|
pmadapter->pcard_sd->mpa_rx.head_ptr, DMA_ALIGNMENT);
|
|
|
|
} else {
|
|
|
|
PRINTM(MMSG, "wlan: Enable RX SG mode\n");
|
|
|
|
pmadapter->pcard_sd->mpa_rx.head_ptr = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf = MNULL;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf_size = mpa_rx_buf_size;
|
|
|
|
error:
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
|
|
wlan_free_sdio_mpa_buffers(pmadapter);
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function frees buffers for the SDIO aggregation
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
*
|
|
|
|
* @return MLAN_STATUS_SUCCESS
|
|
|
|
*/
|
|
|
|
mlan_status wlan_free_sdio_mpa_buffers(mlan_adapter *pmadapter)
|
|
|
|
{
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->mpa_tx.buf) {
|
|
|
|
pcb->moal_mfree(pmadapter->pmoal_handle,
|
|
|
|
(t_u8 *)pmadapter->pcard_sd->mpa_tx.head_ptr);
|
|
|
|
pmadapter->pcard_sd->mpa_tx.head_ptr = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_tx.buf = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_tx.buf_size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->mpa_rx.buf) {
|
|
|
|
pcb->moal_mfree(pmadapter->pmoal_handle,
|
|
|
|
(t_u8 *)pmadapter->pcard_sd->mpa_rx.head_ptr);
|
|
|
|
pmadapter->pcard_sd->mpa_rx.head_ptr = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf_size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function re-allocate rx mpa buffer
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
*
|
|
|
|
* @return MLAN_STATUS_SUCCESS
|
|
|
|
*/
|
|
|
|
mlan_status wlan_re_alloc_sdio_rx_mpa_buffer(mlan_adapter *pmadapter)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
t_u8 mp_aggr_pkt_limit = SDIO_MP_AGGR_DEF_PKT_LIMIT;
|
|
|
|
t_u32 mpa_rx_buf_size = SDIO_MP_AGGR_BUF_SIZE_MAX;
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->mpa_rx.buf) {
|
|
|
|
pcb->moal_mfree(pmadapter->pmoal_handle,
|
|
|
|
(t_u8 *)pmadapter->pcard_sd->mpa_rx.head_ptr);
|
|
|
|
pmadapter->pcard_sd->mpa_rx.head_ptr = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf_size = 0;
|
|
|
|
}
|
|
|
|
if (pmadapter->pcard_sd->sdio_rx_aggr_enable) {
|
|
|
|
mpa_rx_buf_size = MAX(mpa_rx_buf_size, SDIO_CMD53_MAX_SIZE);
|
|
|
|
/** reallocate rx buffer for recover when single port rx
|
|
|
|
* aggregation enabled */
|
|
|
|
if (pmadapter->pcard_sd->rx_buffer) {
|
|
|
|
pcb->moal_mfree(pmadapter->pmoal_handle,
|
|
|
|
(t_u8 *)pmadapter->pcard_sd->rx_buffer);
|
|
|
|
pmadapter->pcard_sd->rx_buffer = MNULL;
|
|
|
|
pmadapter->pcard_sd->rx_buf = MNULL;
|
|
|
|
}
|
|
|
|
ret = pmadapter->callbacks.moal_malloc(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
SDIO_CMD53_MAX_SIZE + DMA_ALIGNMENT,
|
|
|
|
MLAN_MEM_DEF | MLAN_MEM_DMA,
|
|
|
|
(t_u8 **)&pmadapter->pcard_sd->rx_buffer);
|
|
|
|
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS ||
|
|
|
|
!pmadapter->pcard_sd->rx_buffer) {
|
|
|
|
PRINTM(MERROR, "Failed to allocate receive buffer\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->rx_buf = (t_u8 *)ALIGN_ADDR(
|
|
|
|
pmadapter->pcard_sd->rx_buffer, DMA_ALIGNMENT);
|
|
|
|
}
|
|
|
|
if ((pmadapter->pcard_sd->max_segs < mp_aggr_pkt_limit) ||
|
|
|
|
(pmadapter->pcard_sd->max_seg_size <
|
|
|
|
pmadapter->pcard_sd->max_sp_rx_size)) {
|
|
|
|
ret = pcb->moal_malloc(
|
|
|
|
pmadapter->pmoal_handle,
|
|
|
|
mpa_rx_buf_size + DMA_ALIGNMENT,
|
|
|
|
MLAN_MEM_DEF | MLAN_MEM_DMA,
|
|
|
|
(t_u8 **)&pmadapter->pcard_sd->mpa_rx.head_ptr);
|
|
|
|
if (ret != MLAN_STATUS_SUCCESS ||
|
|
|
|
!pmadapter->pcard_sd->mpa_rx.head_ptr) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"Could not allocate buffer for SDIO MP RX aggr\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf = (t_u8 *)ALIGN_ADDR(
|
|
|
|
pmadapter->pcard_sd->mpa_rx.head_ptr, DMA_ALIGNMENT);
|
|
|
|
} else {
|
|
|
|
PRINTM(MMSG, "wlan: Enable RX SG mode\n");
|
|
|
|
pmadapter->pcard_sd->mpa_rx.head_ptr = MNULL;
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf = MNULL;
|
|
|
|
}
|
|
|
|
pmadapter->pcard_sd->mpa_rx.buf_size = mpa_rx_buf_size;
|
|
|
|
PRINTM(MMSG, "mpa_rx_buf_size=%d\n", mpa_rx_buf_size);
|
|
|
|
error:
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
mlan_status wlan_pm_sdio_wakeup_card(pmlan_adapter pmadapter, t_u8 timeout)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
t_u32 age_ts_usec;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
PRINTM(MEVENT, "Wakeup device...\n");
|
|
|
|
pmadapter->callbacks.moal_get_system_time(pmadapter->pmoal_handle,
|
|
|
|
&pmadapter->pm_wakeup_in_secs,
|
|
|
|
&age_ts_usec);
|
|
|
|
|
|
|
|
if (timeout) {
|
|
|
|
pmadapter->callbacks.moal_start_timer(
|
|
|
|
pmadapter->pmoal_handle, pmadapter->pwakeup_fw_timer,
|
|
|
|
MFALSE, MRVDRV_TIMER_3S);
|
|
|
|
pmadapter->wakeup_fw_timer_is_set = MTRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG, HOST_POWER_UP);
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function resets the PM setting of the card.
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
*
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_pm_sdio_reset_card(pmlan_adapter pmadapter)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
ret = pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG, 0);
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function issues commands to initialize firmware
|
|
|
|
*
|
|
|
|
* @param priv A pointer to mlan_private structure
|
|
|
|
*
|
|
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
|
|
*/
|
|
|
|
mlan_status wlan_set_sdio_gpio_int(pmlan_private priv)
|
|
|
|
{
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
pmlan_adapter pmadapter = MNULL;
|
|
|
|
HostCmd_DS_SDIO_GPIO_INT_CONFIG sdio_int_cfg;
|
|
|
|
|
|
|
|
if (!priv) {
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
pmadapter = priv->adapter;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
if (pmadapter->pcard_sd->int_mode == INT_MODE_GPIO) {
|
|
|
|
if (pmadapter->pcard_sd->gpio_pin != GPIO_INT_NEW_MODE) {
|
|
|
|
PRINTM(MINFO,
|
|
|
|
"SDIO_GPIO_INT_CONFIG: interrupt mode is GPIO\n");
|
|
|
|
sdio_int_cfg.action = HostCmd_ACT_GEN_SET;
|
|
|
|
sdio_int_cfg.gpio_pin = pmadapter->pcard_sd->gpio_pin;
|
|
|
|
sdio_int_cfg.gpio_int_edge = INT_FALLING_EDGE;
|
|
|
|
sdio_int_cfg.gpio_pulse_width = DELAY_1_US;
|
|
|
|
ret = wlan_prepare_cmd(priv,
|
|
|
|
HostCmd_CMD_SDIO_GPIO_INT_CONFIG,
|
|
|
|
HostCmd_ACT_GEN_SET, 0, MNULL,
|
|
|
|
&sdio_int_cfg);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
PRINTM(MERROR,
|
|
|
|
"SDIO_GPIO_INT_CONFIG: send command fail\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
PRINTM(MINFO, "SDIO_GPIO_INT_CONFIG: interrupt mode is SDIO\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function prepares command of SDIO GPIO interrupt
|
|
|
|
*
|
|
|
|
* @param pmpriv A pointer to mlan_private structure
|
|
|
|
* @param cmd A pointer to HostCmd_DS_COMMAND structure
|
|
|
|
* @param cmd_action The action: GET or SET
|
|
|
|
* @param pdata_buf A pointer to data buffer
|
|
|
|
* @return MLAN_STATUS_SUCCESS
|
|
|
|
*/
|
|
|
|
mlan_status wlan_cmd_sdio_gpio_int(pmlan_private pmpriv,
|
|
|
|
HostCmd_DS_COMMAND *cmd, t_u16 cmd_action,
|
|
|
|
t_void *pdata_buf)
|
|
|
|
{
|
|
|
|
HostCmd_DS_SDIO_GPIO_INT_CONFIG *psdio_gpio_int =
|
|
|
|
&cmd->params.sdio_gpio_int;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
cmd->command = wlan_cpu_to_le16(HostCmd_CMD_SDIO_GPIO_INT_CONFIG);
|
|
|
|
cmd->size = wlan_cpu_to_le16((sizeof(HostCmd_DS_SDIO_GPIO_INT_CONFIG)) +
|
|
|
|
S_DS_GEN);
|
|
|
|
|
|
|
|
memset(pmpriv->adapter, psdio_gpio_int, 0,
|
|
|
|
sizeof(HostCmd_DS_SDIO_GPIO_INT_CONFIG));
|
|
|
|
if (cmd_action == HostCmd_ACT_GEN_SET) {
|
|
|
|
memcpy_ext(pmpriv->adapter, psdio_gpio_int, pdata_buf,
|
|
|
|
sizeof(HostCmd_DS_SDIO_GPIO_INT_CONFIG),
|
|
|
|
sizeof(HostCmd_DS_SDIO_GPIO_INT_CONFIG));
|
|
|
|
psdio_gpio_int->action =
|
|
|
|
wlan_cpu_to_le16(psdio_gpio_int->action);
|
|
|
|
psdio_gpio_int->gpio_pin =
|
|
|
|
wlan_cpu_to_le16(psdio_gpio_int->gpio_pin);
|
|
|
|
psdio_gpio_int->gpio_int_edge =
|
|
|
|
wlan_cpu_to_le16(psdio_gpio_int->gpio_int_edge);
|
|
|
|
psdio_gpio_int->gpio_pulse_width =
|
|
|
|
wlan_cpu_to_le16(psdio_gpio_int->gpio_pulse_width);
|
|
|
|
}
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
mlan_status wlan_reset_fw(pmlan_adapter pmadapter)
|
|
|
|
{
|
|
|
|
t_u32 tries = 0;
|
|
|
|
t_u32 value = 1;
|
|
|
|
t_u32 reset_reg = pmadapter->pcard_sd->reg->fw_reset_reg;
|
|
|
|
t_u8 reset_val = pmadapter->pcard_sd->reg->fw_reset_val;
|
|
|
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
|
|
|
|
ENTER();
|
|
|
|
wlan_pm_sdio_wakeup_card(pmadapter, MFALSE);
|
|
|
|
|
|
|
|
/** wait SOC fully wake up */
|
|
|
|
for (tries = 0; tries < MAX_POLL_TRIES; ++tries) {
|
|
|
|
if (MLAN_STATUS_SUCCESS ==
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle, reset_reg,
|
|
|
|
0xba)) {
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle, reset_reg,
|
|
|
|
&value);
|
|
|
|
if (value == 0xba) {
|
|
|
|
PRINTM(MMSG, "FW wake up\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pcb->moal_udelay(pmadapter->pmoal_handle, 1000);
|
|
|
|
}
|
|
|
|
/* Write register to notify FW */
|
|
|
|
if (MLAN_STATUS_FAILURE == pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
reset_reg, reset_val)) {
|
|
|
|
PRINTM(MERROR, "Failed to write register.\n");
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
#if defined(SD8997) || defined(SD8977) || defined(SD8987) || \
|
|
|
|
defined(SD9098) || defined(SD9097) || defined(SD8978)
|
|
|
|
if (MFALSE
|
|
|
|
#ifdef SD8997
|
|
|
|
|| IS_SD8997(pmadapter->card_type)
|
|
|
|
#endif
|
|
|
|
#ifdef SD8977
|
|
|
|
|| IS_SD8977(pmadapter->card_type)
|
|
|
|
#endif
|
|
|
|
#ifdef SD8978
|
|
|
|
|| IS_SD8978(pmadapter->card_type)
|
|
|
|
#endif
|
|
|
|
#ifdef SD8987
|
|
|
|
|| IS_SD8987(pmadapter->card_type)
|
|
|
|
#endif
|
|
|
|
#ifdef SD9098
|
|
|
|
|| IS_SD9098(pmadapter->card_type)
|
|
|
|
#endif
|
|
|
|
#ifdef SD9097
|
|
|
|
|| IS_SD9097(pmadapter->card_type)
|
|
|
|
#endif
|
|
|
|
) {
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG, &value);
|
|
|
|
pcb->moal_write_reg(pmadapter->pmoal_handle,
|
|
|
|
HOST_TO_CARD_EVENT_REG,
|
|
|
|
value | HOST_POWER_UP);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Poll register around 100 ms */
|
|
|
|
for (tries = 0; tries < MAX_POLL_TRIES; ++tries) {
|
|
|
|
pcb->moal_read_reg(pmadapter->pmoal_handle, reset_reg, &value);
|
|
|
|
if (value == 0)
|
|
|
|
/* FW is ready */
|
|
|
|
break;
|
|
|
|
pcb->moal_udelay(pmadapter->pmoal_handle, 1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value) {
|
|
|
|
PRINTM(MERROR, "Failed to poll FW reset register %X=0x%x\n",
|
|
|
|
reset_reg, value);
|
|
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
PRINTM(MMSG, "FW Reset success\n");
|
|
|
|
ret = wlan_sdio_probe(pmadapter);
|
|
|
|
done:
|
|
|
|
LEAVE();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief This function handle event/data/cmd complete
|
|
|
|
*
|
|
|
|
* @param pmadapter A pointer to mlan_adapter structure
|
|
|
|
* @param pmbuf A pointer to the mlan_buffer
|
|
|
|
* @return N/A
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_data_evt_complete(pmlan_adapter pmadapter,
|
|
|
|
mlan_buffer *pmbuf, mlan_status status)
|
|
|
|
{
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
mlan_status wlan_sdio_handle_rx_packet(mlan_adapter *pmadapter,
|
|
|
|
pmlan_buffer pmbuf)
|
|
|
|
{
|
|
|
|
ENTER();
|
|
|
|
|
|
|
|
wlan_sdio_deaggr_rx_pkt(pmadapter, pmbuf);
|
|
|
|
|
|
|
|
LEAVE();
|
|
|
|
return MLAN_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
mlan_adapter_operations mlan_sdio_ops = {
|
|
|
|
.dnld_fw = wlan_sdio_dnld_fw,
|
|
|
|
.interrupt = wlan_sdio_interrupt,
|
|
|
|
.process_int_status = wlan_process_sdio_int_status,
|
|
|
|
.host_to_card = wlan_sdio_host_to_card_ext,
|
|
|
|
.wakeup_card = wlan_pm_sdio_wakeup_card,
|
|
|
|
.reset_card = wlan_pm_sdio_reset_card,
|
|
|
|
.event_complete = wlan_sdio_data_evt_complete,
|
|
|
|
.data_complete = wlan_sdio_data_evt_complete,
|
|
|
|
.cmdrsp_complete = wlan_sdio_data_evt_complete,
|
|
|
|
.handle_rx_packet = wlan_sdio_handle_rx_packet,
|
|
|
|
|
|
|
|
.intf_header_len = SDIO_INTF_HEADER_LEN,
|
|
|
|
};
|