2017-03-12 16:48:09 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* drivers/wireless/ieee80211/bcmf_sdio.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 2017 Gregory Nutt. All rights reserved.
|
|
|
|
* Author: Simon Piriou <spiriou31@gmail.com>
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in
|
|
|
|
* the documentation and/or other materials provided with the
|
|
|
|
* distribution.
|
|
|
|
* 3. Neither the name NuttX nor the names of its contributors may be
|
|
|
|
* used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <nuttx/compiler.h>
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <debug.h>
|
|
|
|
#include <errno.h>
|
2017-04-16 11:28:08 +02:00
|
|
|
#include <queue.h>
|
2017-04-23 22:17:43 +02:00
|
|
|
#include <semaphore.h>
|
2017-04-30 20:29:48 +02:00
|
|
|
#include <assert.h>
|
2017-03-12 16:48:09 +01:00
|
|
|
|
|
|
|
#include <nuttx/kmalloc.h>
|
|
|
|
#include <nuttx/arch.h>
|
2017-04-13 20:31:39 +02:00
|
|
|
#include <nuttx/kthread.h>
|
2017-04-28 19:28:29 +02:00
|
|
|
#include <nuttx/wdog.h>
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-03-14 21:06:19 +01:00
|
|
|
#include <nuttx/wireless/ieee80211/mmc_sdio.h>
|
2017-03-12 16:48:09 +01:00
|
|
|
#include <nuttx/wireless/ieee80211/bcmf_sdio.h>
|
|
|
|
#include <nuttx/wireless/ieee80211/bcmf_board.h>
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
#include "bcmf_sdio.h"
|
|
|
|
#include "bcmf_core.h"
|
2017-04-13 20:31:39 +02:00
|
|
|
#include "bcmf_sdpcm.h"
|
2017-04-30 20:29:48 +02:00
|
|
|
#include "bcmf_utils.h"
|
2017-03-20 22:40:25 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
#include "bcmf_sdio_core.h"
|
|
|
|
#include "bcmf_sdio_regs.h"
|
|
|
|
|
|
|
|
/* Supported chip configurations */
|
|
|
|
#ifdef CONFIG_IEEE80211_BROADCOM_BCM43362
|
|
|
|
extern const struct bcmf_sdio_chip bcmf_43362_config_sdio;
|
|
|
|
#endif
|
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Pre-processor Definitions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#define BCMF_DEVICE_RESET_DELAY_MS 10
|
|
|
|
#define BCMF_DEVICE_START_DELAY_MS 10
|
2017-03-14 21:06:19 +01:00
|
|
|
#define BCMF_CLOCK_SETUP_DELAY_MS 500
|
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
#define BCMF_THREAD_NAME "bcmf"
|
|
|
|
#define BCMF_THREAD_STACK_SIZE 2048
|
|
|
|
|
|
|
|
#define BCMF_WAITDOG_TIMEOUT_TICK (5*CLOCKS_PER_SEC)
|
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Types
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Function Prototypes
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
static int bcmf_probe(FAR struct bcmf_sdio_dev_s *sbus);
|
|
|
|
static int bcmf_hwinitialize(FAR struct bcmf_sdio_dev_s *sbus);
|
|
|
|
static void bcmf_hwuninitialize(FAR struct bcmf_sdio_dev_s *sbus);
|
|
|
|
static int bcmf_chipinitialize(FAR struct bcmf_sdio_dev_s *sbus);
|
2017-03-20 22:40:25 +01:00
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
static int bcmf_oob_irq(int irq, FAR void *context, FAR void *arg);
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
static int bcmf_sdio_bus_sleep(FAR struct bcmf_sdio_dev_s *sbus, bool sleep);
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
static void bcmf_sdio_waitdog_timeout(int argc, wdparm_t arg1, ...);
|
|
|
|
static int bcmf_sdio_thread(int argc, char **argv);
|
|
|
|
|
|
|
|
static int bcmf_sdio_find_block_size(unsigned int size);
|
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Data
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
/* FIXME remove */
|
|
|
|
FAR struct bcmf_dev_s *g_sdio_priv;
|
|
|
|
|
2017-04-30 20:29:48 +02:00
|
|
|
/* Buffer pool for SDIO bus interface
|
2017-05-04 02:20:57 +02:00
|
|
|
* This pool is shared between all driver devices
|
|
|
|
*/
|
2017-04-30 20:29:48 +02:00
|
|
|
|
|
|
|
static struct bcmf_sdio_frame g_pktframes[BCMF_PKT_POOL_SIZE];
|
|
|
|
|
|
|
|
// TODO free_queue should be static
|
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
int bcmf_oob_irq(int irq, FAR void *context, FAR void *arg)
|
2017-03-20 22:40:25 +01:00
|
|
|
{
|
2017-05-04 02:20:57 +02:00
|
|
|
FAR struct bcmf_sdio_dev_s *sbus = (struct bcmf_sdio_dev_s *)arg;
|
2017-04-13 20:31:39 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
if (sbus->ready)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
|
|
|
/* Signal bmcf thread */
|
2017-05-04 02:20:57 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->irq_pending = true;
|
2017-04-13 20:31:39 +02:00
|
|
|
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&sbus->thread_signal);
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_sdio_bus_sleep(FAR struct bcmf_sdio_dev_s *sbus, bool sleep)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int loops;
|
|
|
|
uint8_t value;
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
if (sbus->sleeping == sleep)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sleep)
|
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->sleeping = true;
|
|
|
|
return bcmf_write_reg(sbus, 1, SBSDIO_FUNC1_CHIPCLKCSR, 0);
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Request HT Avail */
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_write_reg(sbus, 1, SBSDIO_FUNC1_CHIPCLKCSR,
|
2017-04-13 20:31:39 +02:00
|
|
|
SBSDIO_HT_AVAIL_REQ | SBSDIO_FORCE_HT);
|
|
|
|
if (ret != OK)
|
|
|
|
{
|
2017-04-24 00:24:47 +02:00
|
|
|
wlerr("HT Avail request failed %d\n", ret);
|
2017-04-13 20:31:39 +02:00
|
|
|
return ret;
|
|
|
|
}
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
/* Wait for High Troughput clock */
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
loops = 20;
|
|
|
|
while (--loops > 0)
|
|
|
|
{
|
|
|
|
up_mdelay(1);
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_read_reg(sbus, 1, SBSDIO_FUNC1_CHIPCLKCSR, &value);
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
if (value & SBSDIO_HT_AVAIL)
|
|
|
|
{
|
|
|
|
/* High Throughput clock is ready */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
if (loops <= 0)
|
|
|
|
{
|
2017-04-24 00:24:47 +02:00
|
|
|
wlerr("HT clock not ready\n");
|
2017-04-13 20:31:39 +02:00
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->sleeping = false;
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
return OK;
|
2017-03-12 16:48:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: bcmf_probe
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_probe(FAR struct bcmf_sdio_dev_s *sbus)
|
2017-03-12 16:48:09 +01:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2017-03-14 21:06:19 +01:00
|
|
|
/* Probe sdio card compatible device */
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = sdio_probe(sbus->sdio_dev);
|
2017-03-14 21:06:19 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
goto exit_error;
|
|
|
|
}
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-03-14 21:06:19 +01:00
|
|
|
/* Set FN0 / FN1 / FN2 default block size */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = sdio_set_blocksize(sbus->sdio_dev, 0, 64);
|
2017-03-14 21:06:19 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
goto exit_error;
|
|
|
|
}
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = sdio_set_blocksize(sbus->sdio_dev, 1, 64);
|
2017-03-14 21:06:19 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
goto exit_error;
|
|
|
|
}
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = sdio_set_blocksize(sbus->sdio_dev, 2, 64);
|
2017-03-12 16:48:09 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
goto exit_error;
|
|
|
|
}
|
|
|
|
|
2017-03-14 21:06:19 +01:00
|
|
|
/* Enable device interrupts for FN0, FN1 and FN2 */
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_write_reg(sbus, 0, SDIO_CCCR_INTEN,
|
2017-03-20 22:40:25 +01:00
|
|
|
(1 << 0) | (1 << 1) | (1 << 2));
|
2017-03-14 21:06:19 +01:00
|
|
|
if (ret != OK)
|
2017-03-12 16:48:09 +01:00
|
|
|
{
|
|
|
|
goto exit_error;
|
|
|
|
}
|
|
|
|
|
2017-03-14 21:06:19 +01:00
|
|
|
/* Default device clock speed is up to 25 Mhz
|
|
|
|
* We could set EHS bit to operate at a clock rate up to 50 Mhz */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
SDIO_CLOCK(sbus->sdio_dev, CLOCK_SD_TRANSFER_4BIT);
|
2017-03-14 21:06:19 +01:00
|
|
|
up_mdelay(BCMF_CLOCK_SETUP_DELAY_MS);
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
/* Enable bus FN1 */
|
2017-03-14 21:06:19 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = sdio_enable_function(sbus->sdio_dev, 1);
|
2017-03-26 17:42:53 +02:00
|
|
|
if (ret != OK)
|
2017-03-14 21:06:19 +01:00
|
|
|
{
|
2017-03-26 17:42:53 +02:00
|
|
|
goto exit_error;
|
2017-03-14 21:06:19 +01:00
|
|
|
}
|
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
return OK;
|
|
|
|
|
|
|
|
exit_error:
|
|
|
|
|
2017-04-24 00:24:47 +02:00
|
|
|
wlerr("ERROR: failed to probe device %d\n", sbus->minor);
|
2017-03-12 16:48:09 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-03-14 21:06:19 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: bcmf_businitialize
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_businitialize(FAR struct bcmf_sdio_dev_s *sbus)
|
2017-03-14 21:06:19 +01:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int loops;
|
2017-03-26 17:42:53 +02:00
|
|
|
uint8_t value;
|
2017-03-14 21:06:19 +01:00
|
|
|
|
|
|
|
/* Send Active Low-Power clock request */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_write_reg(sbus, 1, SBSDIO_FUNC1_CHIPCLKCSR,
|
2017-03-20 22:40:25 +01:00
|
|
|
SBSDIO_FORCE_HW_CLKREQ_OFF |
|
|
|
|
SBSDIO_ALP_AVAIL_REQ |
|
|
|
|
SBSDIO_FORCE_ALP);
|
2017-03-14 21:06:19 +01:00
|
|
|
|
|
|
|
if (ret != OK)
|
|
|
|
{
|
2017-03-20 22:40:25 +01:00
|
|
|
return ret;
|
2017-03-14 21:06:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
loops = 10;
|
|
|
|
while (--loops > 0)
|
|
|
|
{
|
|
|
|
up_mdelay(10);
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_read_reg(sbus, 1, SBSDIO_FUNC1_CHIPCLKCSR, &value);
|
2017-03-14 21:06:19 +01:00
|
|
|
|
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-03-20 22:40:25 +01:00
|
|
|
if (value & SBSDIO_ALP_AVAIL)
|
2017-03-14 21:06:19 +01:00
|
|
|
{
|
|
|
|
/* Active Low-Power clock is ready */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (loops <= 0)
|
|
|
|
{
|
2017-04-24 00:24:47 +02:00
|
|
|
wlerr("failed to enable ALP\n");
|
2017-03-14 21:06:19 +01:00
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clear Active Low-Power clock request */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_write_reg(sbus, 1, SBSDIO_FUNC1_CHIPCLKCSR, 0);
|
2017-03-14 21:06:19 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Disable pull-ups on SDIO cmd, d0-2 lines */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_write_reg(sbus, 1, SBSDIO_FUNC1_SDIOPULLUP, 0);
|
2017-03-14 21:06:19 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-03-20 22:40:25 +01:00
|
|
|
/* Do chip specific initialization */
|
2017-03-14 21:06:19 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_chipinitialize(sbus);
|
2017-03-20 22:40:25 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
2017-03-14 21:06:19 +01:00
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
/* Upload firmware */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_core_upload_firmware(sbus);
|
2017-03-26 17:42:53 +02:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable FN2 (frame transfers) */
|
2017-03-14 21:06:19 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = sdio_enable_function(sbus->sdio_dev, 2);
|
2017-03-26 17:42:53 +02:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
2017-03-14 21:06:19 +01:00
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_bus_setup_interrupts(FAR struct bcmf_sdio_dev_s *sbus)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
/* Configure gpio interrupt pin */
|
2017-03-20 22:40:25 +01:00
|
|
|
|
2017-05-04 02:20:57 +02:00
|
|
|
bcmf_board_setup_oob_irq(sbus->minor, bcmf_oob_irq, (void *)sbus);
|
2017-03-20 22:40:25 +01:00
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
/* Enable function 2 interrupt */
|
2017-03-20 22:40:25 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = sdio_enable_interrupt(sbus->sdio_dev, 0);
|
2017-03-26 17:42:53 +02:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = sdio_enable_interrupt(sbus->sdio_dev, 2);
|
2017-03-26 17:42:53 +02:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
2017-03-20 22:40:25 +01:00
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
/* Redirect, configure and enable io for out-of-band interrupt signal */
|
2017-03-20 22:40:25 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_write_reg(sbus, 0, SDIO_CCCR_BRCM_SEPINT,
|
2017-04-16 11:28:08 +02:00
|
|
|
SDIO_SEPINT_MASK | SDIO_SEPINT_OE | SDIO_SEPINT_ACT_HI);
|
2017-03-26 17:42:53 +02:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
/* Wake up chip to be sure function 2 is running */
|
2017-03-26 17:42:53 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_sdio_bus_sleep(sbus, false);
|
2017-04-13 20:31:39 +02:00
|
|
|
if (ret != OK)
|
2017-03-26 17:42:53 +02:00
|
|
|
{
|
2017-04-13 20:31:39 +02:00
|
|
|
return ret;
|
2017-03-26 17:42:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* FN2 successfully enabled, set core and enable interrupts */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_write_sbregw(sbus,
|
|
|
|
CORE_BUS_REG(sbus->chip->core_base[SDIOD_CORE_ID],
|
2017-03-26 17:42:53 +02:00
|
|
|
hostintmask), I_HMB_SW_MASK);
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_write_sbregb(sbus,
|
|
|
|
CORE_BUS_REG(sbus->chip->core_base[SDIOD_CORE_ID],
|
2017-03-26 17:42:53 +02:00
|
|
|
funcintmask), 2);
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_write_reg(sbus, 1, SBSDIO_WATERMARK, 8);
|
2017-03-14 21:06:19 +01:00
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: bcmf_hwinitialize
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_hwinitialize(FAR struct bcmf_sdio_dev_s *sbus)
|
2017-03-12 16:48:09 +01:00
|
|
|
{
|
|
|
|
/* Attach and prepare SDIO interrupts */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
SDIO_ATTACH(sbus->sdio_dev);
|
2017-03-12 16:48:09 +01:00
|
|
|
|
|
|
|
/* Set ID mode clocking (<400KHz) */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
SDIO_CLOCK(sbus->sdio_dev, CLOCK_IDMODE);
|
2017-03-12 16:48:09 +01:00
|
|
|
|
|
|
|
/* Configure hardware */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_board_initialize(sbus->minor);
|
2017-03-12 16:48:09 +01:00
|
|
|
|
|
|
|
/* Reset and power device */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_board_reset(sbus->minor, true);
|
|
|
|
bcmf_board_power(sbus->minor, true);
|
2017-03-12 16:48:09 +01:00
|
|
|
up_mdelay(BCMF_DEVICE_RESET_DELAY_MS);
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_board_reset(sbus->minor, false);
|
2017-03-12 16:48:09 +01:00
|
|
|
|
|
|
|
/* Wait for device to start */
|
|
|
|
|
|
|
|
up_mdelay(BCMF_DEVICE_START_DELAY_MS);
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: bcmf_hwuninitialize
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
void bcmf_hwuninitialize(FAR struct bcmf_sdio_dev_s *sbus)
|
2017-03-12 16:48:09 +01:00
|
|
|
{
|
|
|
|
/* Shutdown device */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_board_power(sbus->minor, false);
|
|
|
|
bcmf_board_reset(sbus->minor, true);
|
2017-03-12 16:48:09 +01:00
|
|
|
}
|
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
int bcmf_sdio_find_block_size(unsigned int size)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int size_copy = size;
|
2017-05-04 02:20:57 +02:00
|
|
|
while (size_copy)
|
|
|
|
{
|
|
|
|
size_copy >>= 1;
|
|
|
|
ret++;
|
|
|
|
}
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
if (size & (size-1))
|
|
|
|
{
|
2017-05-04 02:20:57 +02:00
|
|
|
return 1 << ret;
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
2017-05-04 02:20:57 +02:00
|
|
|
|
|
|
|
return 1 << (ret - 1);
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: bcmf_transfer_bytes
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_transfer_bytes(FAR struct bcmf_sdio_dev_s *sbus, bool write,
|
2017-03-26 17:42:53 +02:00
|
|
|
uint8_t function, uint32_t address,
|
|
|
|
uint8_t *buf, unsigned int len)
|
|
|
|
{
|
2017-04-13 20:31:39 +02:00
|
|
|
unsigned int blocklen;
|
|
|
|
unsigned int nblocks;
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
/* Use rw_io_direct method if len is 1 */
|
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
if (len == 0)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
if (len == 1)
|
|
|
|
{
|
|
|
|
if (write)
|
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
return sdio_io_rw_direct(sbus->sdio_dev, write,
|
2017-03-26 17:42:53 +02:00
|
|
|
function, address, *buf, NULL);
|
|
|
|
}
|
2017-04-23 22:17:43 +02:00
|
|
|
return sdio_io_rw_direct(sbus->sdio_dev, write,
|
2017-03-26 17:42:53 +02:00
|
|
|
function, address, 0, buf);
|
|
|
|
}
|
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
/* Find best block settings for transfer */
|
2017-03-26 17:42:53 +02:00
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
if (len >= 64)
|
2017-03-26 17:42:53 +02:00
|
|
|
{
|
2017-04-13 20:31:39 +02:00
|
|
|
/* Use block mode */
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
blocklen = 64;
|
|
|
|
nblocks = (len+63) / 64;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-04-13 20:31:39 +02:00
|
|
|
/* Use byte mode */
|
|
|
|
|
|
|
|
blocklen = bcmf_sdio_find_block_size(len);
|
2017-03-26 17:42:53 +02:00
|
|
|
nblocks = 0;
|
|
|
|
}
|
2017-04-13 20:31:39 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
return sdio_io_rw_extended(sbus->sdio_dev, write,
|
2017-03-26 17:42:53 +02:00
|
|
|
function, address, true, buf, blocklen, nblocks);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: bcmf_read_reg
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_read_reg(FAR struct bcmf_sdio_dev_s *sbus, uint8_t function,
|
2017-03-26 17:42:53 +02:00
|
|
|
uint32_t address, uint8_t *reg)
|
|
|
|
{
|
|
|
|
*reg = 0;
|
2017-04-23 22:17:43 +02:00
|
|
|
return bcmf_transfer_bytes(sbus, false, function, address, reg, 1);
|
2017-03-26 17:42:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: bcmf_write_reg
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_write_reg(FAR struct bcmf_sdio_dev_s *sbus, uint8_t function,
|
2017-03-26 17:42:53 +02:00
|
|
|
uint32_t address, uint8_t reg)
|
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
return bcmf_transfer_bytes(sbus, true, function, address, ®, 1);
|
2017-03-26 17:42:53 +02:00
|
|
|
}
|
|
|
|
|
2017-04-16 11:28:08 +02:00
|
|
|
/****************************************************************************
|
2017-04-23 22:17:43 +02:00
|
|
|
* Name: bcmf_bus_sdio_initialize
|
2017-04-16 11:28:08 +02:00
|
|
|
****************************************************************************/
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_bus_sdio_initialize(FAR struct bcmf_dev_s *priv,
|
|
|
|
int minor, FAR struct sdio_dev_s *dev)
|
2017-04-16 11:28:08 +02:00
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
int ret;
|
|
|
|
FAR struct bcmf_sdio_dev_s *sbus;
|
2017-04-16 11:28:08 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
/* Allocate sdio bus structure */
|
2017-04-16 11:28:08 +02:00
|
|
|
|
2017-05-04 02:20:57 +02:00
|
|
|
sbus = (FAR struct bcmf_sdio_dev_s *)kmm_malloc(sizeof(*sbus));
|
2017-04-16 11:28:08 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
if (!sbus)
|
2017-04-16 11:28:08 +02:00
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
return -ENOMEM;
|
2017-04-16 11:28:08 +02:00
|
|
|
}
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
/* Initialize sdio bus device structure */
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
memset(sbus, 0, sizeof(*sbus));
|
|
|
|
sbus->sdio_dev = dev;
|
|
|
|
sbus->minor = minor;
|
|
|
|
sbus->ready = false;
|
|
|
|
sbus->sleeping = true;
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->bus.txframe = bcmf_sdpcm_queue_frame;
|
2017-04-30 20:29:48 +02:00
|
|
|
sbus->bus.rxframe = bcmf_sdpcm_get_rx_frame;
|
|
|
|
sbus->bus.allocate_frame = bcmf_sdpcm_alloc_frame;
|
|
|
|
sbus->bus.free_frame = bcmf_sdpcm_free_frame;
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->bus.stop = NULL; // TODO
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
/* Init transmit frames queue */
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
if ((ret = nxsem_init(&sbus->queue_mutex, 0, 1)) != OK)
|
2017-03-12 16:48:09 +01:00
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
goto exit_free_bus;
|
2017-03-12 16:48:09 +01:00
|
|
|
}
|
2017-05-04 02:20:57 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sq_init(&sbus->tx_queue);
|
2017-04-30 20:29:48 +02:00
|
|
|
sq_init(&sbus->rx_queue);
|
|
|
|
sq_init(&sbus->free_queue);
|
|
|
|
|
|
|
|
/* Setup free buffer list */
|
|
|
|
|
|
|
|
// FIXME this should be static to driver
|
|
|
|
for (ret = 0; ret < BCMF_PKT_POOL_SIZE; ret++)
|
|
|
|
{
|
|
|
|
bcmf_dqueue_push(&sbus->free_queue, &g_pktframes[ret].list_entry);
|
|
|
|
}
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
/* Init thread semaphore */
|
2017-04-13 20:31:39 +02:00
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
if ((ret = nxsem_init(&sbus->thread_signal, 0, 0)) != OK)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
goto exit_free_bus;
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
2017-05-04 02:20:57 +02:00
|
|
|
|
2017-10-03 23:35:24 +02:00
|
|
|
if ((ret = nxsem_setprotocol(&sbus->thread_signal, SEM_PRIO_NONE)) != OK)
|
2017-04-16 11:28:08 +02:00
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
goto exit_free_bus;
|
2017-04-16 11:28:08 +02:00
|
|
|
}
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
/* Init thread waitdog */
|
2017-04-16 11:28:08 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->waitdog = wd_create();
|
|
|
|
if (!sbus->waitdog)
|
2017-04-16 11:28:08 +02:00
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto exit_free_bus;
|
2017-04-16 11:28:08 +02:00
|
|
|
}
|
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
/* Initialize device hardware */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_hwinitialize(sbus);
|
2017-03-12 16:48:09 +01:00
|
|
|
|
|
|
|
if (ret != OK)
|
|
|
|
{
|
2017-04-13 20:31:39 +02:00
|
|
|
goto exit_free_waitdog;
|
2017-03-12 16:48:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Probe device */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_probe(sbus);
|
2017-03-12 16:48:09 +01:00
|
|
|
|
2017-03-14 21:06:19 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
goto exit_uninit_hw;
|
|
|
|
}
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
/* Initialize device bus */
|
2017-03-14 21:06:19 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_businitialize(sbus);
|
2017-03-14 21:06:19 +01:00
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
goto exit_uninit_hw;
|
|
|
|
}
|
|
|
|
|
2017-03-26 17:42:53 +02:00
|
|
|
up_mdelay(100);
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->ready = true;
|
2017-04-13 20:31:39 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_bus_setup_interrupts(sbus);
|
2017-04-13 20:31:39 +02:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
goto exit_uninit_hw;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME global variable for now */
|
|
|
|
g_sdio_priv = priv;
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
/* Register sdio bus */
|
|
|
|
|
|
|
|
priv->bus = &sbus->bus;
|
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
/* Start the waitdog timer */
|
|
|
|
|
2017-04-30 20:29:48 +02:00
|
|
|
wd_start(sbus->waitdog, BCMF_WAITDOG_TIMEOUT_TICK, bcmf_sdio_waitdog_timeout,
|
|
|
|
(wdparm_t)priv);
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
/* Spawn bcmf daemon thread */
|
|
|
|
|
2017-10-16 19:38:00 +02:00
|
|
|
ret = kthread_create(BCMF_THREAD_NAME, SCHED_PRIORITY_MAX,
|
|
|
|
BCMF_THREAD_STACK_SIZE, bcmf_sdio_thread,
|
|
|
|
(FAR char * const *)NULL);
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
if (ret <= 0)
|
|
|
|
{
|
2017-04-24 00:24:47 +02:00
|
|
|
wlerr("Cannot spawn bcmf thread\n");
|
2017-04-13 20:31:39 +02:00
|
|
|
ret = -EBADE;
|
|
|
|
goto exit_uninit_hw;
|
|
|
|
}
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->thread_id = ret;
|
|
|
|
|
|
|
|
/* sdio bus is up and running */
|
2017-04-16 11:28:08 +02:00
|
|
|
|
2017-03-12 16:48:09 +01:00
|
|
|
return OK;
|
|
|
|
|
|
|
|
exit_uninit_hw:
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_hwuninitialize(sbus);
|
2017-04-13 20:31:39 +02:00
|
|
|
exit_free_waitdog:
|
2017-04-23 22:17:43 +02:00
|
|
|
wd_delete(sbus->waitdog);
|
|
|
|
exit_free_bus:
|
|
|
|
kmm_free(sbus);
|
|
|
|
priv->bus = NULL;
|
2017-03-12 16:48:09 +01:00
|
|
|
return ret;
|
|
|
|
}
|
2017-03-20 22:40:25 +01:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
int bcmf_chipinitialize(FAR struct bcmf_sdio_dev_s *sbus)
|
2017-03-20 22:40:25 +01:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
uint32_t value = 0;
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
ret = bcmf_read_sbregw(sbus, SI_ENUM_BASE, &value);
|
2017-03-20 22:40:25 +01:00
|
|
|
if (ret != OK)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int chipid = value & 0xffff;
|
|
|
|
switch (chipid)
|
|
|
|
{
|
2017-04-23 22:17:43 +02:00
|
|
|
#ifdef CONFIG_IEEE80211_BROADCOM_BCM43362
|
2017-03-26 17:42:53 +02:00
|
|
|
case SDIO_DEVICE_ID_BROADCOM_43362:
|
2017-04-24 00:24:47 +02:00
|
|
|
wlinfo("bcm43362 chip detected\n");
|
2017-05-04 02:20:57 +02:00
|
|
|
sbus->chip = (struct bcmf_sdio_chip *)&bcmf_43362_config_sdio;
|
2017-03-20 22:40:25 +01:00
|
|
|
break;
|
2017-04-23 22:17:43 +02:00
|
|
|
#endif
|
2017-03-20 22:40:25 +01:00
|
|
|
default:
|
2017-04-24 00:24:47 +02:00
|
|
|
wlerr("chip 0x%x is not supported\n", chipid);
|
2017-03-20 22:40:25 +01:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
return OK;
|
|
|
|
}
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
void bcmf_sdio_waitdog_timeout(int argc, wdparm_t arg1, ...)
|
|
|
|
{
|
2017-05-04 02:20:57 +02:00
|
|
|
FAR struct bcmf_dev_s *priv = (FAR struct bcmf_dev_s *)arg1;
|
|
|
|
FAR struct bcmf_sdio_dev_s *sbus = (FAR struct bcmf_sdio_dev_s *)priv->bus;
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
/* Notify bcmf thread */
|
2017-04-16 11:28:08 +02:00
|
|
|
|
2017-04-30 20:29:48 +02:00
|
|
|
wlinfo("Notify bcmf thread\n");
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&sbus->thread_signal);
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int bcmf_sdio_thread(int argc, char **argv)
|
|
|
|
{
|
|
|
|
FAR struct bcmf_dev_s *priv = g_sdio_priv;
|
2017-05-04 02:20:57 +02:00
|
|
|
FAR struct bcmf_sdio_dev_s *sbus = (FAR struct bcmf_sdio_dev_s *)priv->bus;
|
2017-10-04 23:22:27 +02:00
|
|
|
int ret;
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-24 00:24:47 +02:00
|
|
|
wlinfo("Enter\n");
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
/* FIXME wait for the chip to be ready to receive commands */
|
|
|
|
|
|
|
|
up_mdelay(50);
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
while (sbus->ready)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
|
|
|
/* Wait for event (device interrupt, user request or waitdog timer) */
|
|
|
|
|
2017-10-04 23:22:27 +02:00
|
|
|
ret = nxsem_wait(&sbus->thread_signal);
|
|
|
|
if (ret < 0)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
2017-04-24 00:24:47 +02:00
|
|
|
wlerr("Error while waiting for semaphore\n");
|
2017-04-13 20:31:39 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Restart the waitdog timer */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
wd_start(sbus->waitdog, BCMF_WAITDOG_TIMEOUT_TICK,
|
2017-04-30 20:29:48 +02:00
|
|
|
bcmf_sdio_waitdog_timeout, (wdparm_t)priv);
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
/* Wake up device */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_sdio_bus_sleep(sbus, false);
|
2017-04-13 20:31:39 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
if (sbus->irq_pending)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
|
|
|
/* Woken up by interrupt, read device status */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->irq_pending = false;
|
2017-04-13 20:31:39 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_read_sbregw(sbus,
|
|
|
|
CORE_BUS_REG(sbus->chip->core_base[SDIOD_CORE_ID],
|
|
|
|
intstatus), &sbus->intstatus);
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
/* Clear interrupts */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
bcmf_write_sbregw(sbus,
|
|
|
|
CORE_BUS_REG(sbus->chip->core_base[SDIOD_CORE_ID],
|
|
|
|
intstatus), sbus->intstatus);
|
2017-04-24 00:24:47 +02:00
|
|
|
// wlinfo("intstatus %x\n", sbus->intstatus);
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* On frame indication, read available frames */
|
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
if (sbus->intstatus & I_HMB_FRAME_IND)
|
2017-04-13 20:31:39 +02:00
|
|
|
{
|
2017-04-24 00:24:47 +02:00
|
|
|
// wlinfo("Frames available\n");
|
2017-04-13 20:31:39 +02:00
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
ret = bcmf_sdpcm_readframe(priv);
|
2017-05-04 02:20:57 +02:00
|
|
|
}
|
|
|
|
while (ret == OK);
|
2017-05-04 02:30:40 +02:00
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
if (ret == -ENODATA)
|
|
|
|
{
|
|
|
|
/* All frames processed */
|
2017-04-16 13:13:11 +02:00
|
|
|
|
2017-04-23 22:17:43 +02:00
|
|
|
sbus->intstatus &= ~I_HMB_FRAME_IND;
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-16 11:28:08 +02:00
|
|
|
/* Send all queued frames */
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
ret = bcmf_sdpcm_sendframe(priv);
|
2017-05-04 02:20:57 +02:00
|
|
|
}
|
|
|
|
while (ret == OK);
|
2017-04-13 20:31:39 +02:00
|
|
|
|
2017-04-30 20:29:48 +02:00
|
|
|
/* Check if RX frames are available */
|
|
|
|
|
|
|
|
if (sbus->intstatus & I_HMB_FRAME_IND)
|
|
|
|
{
|
|
|
|
/* Try again */
|
2017-10-04 23:22:27 +02:00
|
|
|
|
2017-04-30 20:29:48 +02:00
|
|
|
wlinfo("Try read again\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-04-13 20:31:39 +02:00
|
|
|
/* If we're done for now, turn off clock request. */
|
|
|
|
|
2017-04-16 11:28:08 +02:00
|
|
|
// TODO add wakelock
|
2017-04-23 22:17:43 +02:00
|
|
|
// bcmf_sdio_bus_sleep(sbus, true);
|
2017-04-13 20:31:39 +02:00
|
|
|
}
|
2017-04-23 22:17:43 +02:00
|
|
|
|
2017-04-24 00:24:47 +02:00
|
|
|
wlinfo("Exit\n");
|
2017-04-23 22:17:43 +02:00
|
|
|
|
|
|
|
return 0;
|
2017-04-30 20:29:48 +02:00
|
|
|
}
|
|
|
|
|
2017-05-04 02:20:57 +02:00
|
|
|
struct bcmf_sdio_frame *bcmf_sdio_allocate_frame(FAR struct bcmf_dev_s *priv,
|
2017-04-30 20:29:48 +02:00
|
|
|
bool block, bool tx)
|
|
|
|
{
|
2017-05-04 02:20:57 +02:00
|
|
|
FAR struct bcmf_sdio_dev_s *sbus = (FAR struct bcmf_sdio_dev_s *)priv->bus;
|
2017-04-30 20:29:48 +02:00
|
|
|
struct bcmf_sdio_frame *sframe;
|
|
|
|
dq_entry_t *entry = NULL;
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
2017-10-04 23:22:27 +02:00
|
|
|
if (nxsem_wait(&sbus->queue_mutex < 0))
|
2017-04-30 20:29:48 +02:00
|
|
|
{
|
|
|
|
PANIC();
|
|
|
|
}
|
|
|
|
|
|
|
|
// if (!tx || sbus->tx_queue_count < BCMF_PKT_POOL_SIZE-1)
|
|
|
|
{
|
|
|
|
if ((entry = bcmf_dqueue_pop_tail(&sbus->free_queue)) != NULL)
|
|
|
|
{
|
|
|
|
if (tx)
|
|
|
|
{
|
|
|
|
sbus->tx_queue_count += 1;
|
|
|
|
}
|
|
|
|
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&sbus->queue_mutex);
|
2017-04-30 20:29:48 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&sbus->queue_mutex);
|
2017-04-30 20:29:48 +02:00
|
|
|
|
|
|
|
if (block)
|
|
|
|
{
|
|
|
|
// TODO use signaling semaphore
|
|
|
|
wlinfo("alloc failed %d\n", tx);
|
|
|
|
up_mdelay(100);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
wlinfo("No avail buffer\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
sframe = container_of(entry, struct bcmf_sdio_frame, list_entry);
|
|
|
|
|
|
|
|
sframe->header.len = HEADER_SIZE + MAX_NET_DEV_MTU;
|
|
|
|
sframe->header.base = sframe->data;
|
|
|
|
sframe->header.data = sframe->data;
|
|
|
|
sframe->tx = tx;
|
|
|
|
return sframe;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bcmf_sdio_free_frame(FAR struct bcmf_dev_s *priv,
|
|
|
|
struct bcmf_sdio_frame *sframe)
|
|
|
|
{
|
|
|
|
// wlinfo("free %p\n", sframe);
|
2017-05-04 02:20:57 +02:00
|
|
|
FAR struct bcmf_sdio_dev_s *sbus = (FAR struct bcmf_sdio_dev_s *)priv->bus;
|
2017-04-30 20:29:48 +02:00
|
|
|
|
2017-10-04 23:22:27 +02:00
|
|
|
if (nxsem_wait(&sbus->queue_mutex) < 0)
|
2017-04-30 20:29:48 +02:00
|
|
|
{
|
|
|
|
PANIC();
|
|
|
|
}
|
|
|
|
|
|
|
|
bcmf_dqueue_push(&sbus->free_queue, &sframe->list_entry);
|
|
|
|
|
|
|
|
if (sframe->tx)
|
|
|
|
{
|
|
|
|
sbus->tx_queue_count -= 1;
|
|
|
|
}
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&sbus->queue_mutex);
|
2017-05-04 02:20:57 +02:00
|
|
|
}
|