sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Some restructing of the CC3000 build

Browse Source
This commit is contained in:
Gregory Nutt 2013-09-04 16:40:57 -06:00
parent 4377b4f5e8
commit ce6368793a
26 changed files with 429 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
configs/freedom-kl25z/README.txt
View File

@ -409,3 +409,28 @@ Where <subdir> is one of the following:
There is probably enough free memroy to support 3 or 4 application
threads in addition to NSH.
5. This configurations has support for NSH built-in applications. However,
in the default configuration no built-in applications are enabled.
6. This configuration has been used to verify the TI CC3000 wireless
networking module. In order to enable this module, you would need to
make the following changes to the default configuration files:
System Type -> Kinetis peripheral support
CONFIG_KL_SPI0=y : Enable SPI
CONFIG_KL_SPI1=y
Drivers -> SPI
CONFIG_SPI=y : Enable SPI
CONFIG_SPI_EXCHANGE=y
Drivers -> Wireless
CONFIG_WIRELESS=y : Enable wireless support
CONFIG_WL_CC3000=y : Build the CC3000 driver
Applications -> Examples
CONFIG_EXAMPLES_CC3000BASIC=y : CC3000 test example
Applications -> NSH Library
CONFIG_NSH_ARCHINIT=y : Build in CC3000 initialization logic

26
configs/freedom-kl25z/nsh/defconfig
View File

@ -16,7 +16,7 @@ CONFIG_HOST_LINUX=y
#
# Build Configuration
#
CONFIG_APPS_DIR="../apps"
# CONFIG_APPS_DIR="../apps"
# CONFIG_BUILD_2PASS is not set
#
@ -84,6 +84,7 @@ CONFIG_ARCH_CORTEXM0=y
# CONFIG_ARCH_CORTEXM3 is not set
# CONFIG_ARCH_CORTEXM4 is not set
# CONFIG_ARCH_CORTEXA5 is not set
# CONFIG_ARCH_CORTEXA8 is not set
CONFIG_ARCH_FAMILY="armv6-m"
CONFIG_ARCH_CHIP="kl"
CONFIG_ARCH_HAVE_CMNVECTOR=y
@ -94,10 +95,10 @@ CONFIG_ARCH_HAVE_CMNVECTOR=y
#
# ARMV6M Configuration Options
#
# CONFIG_ARMV6M_TOOLCHAIN_BUILDROOT is not set
CONFIG_ARMV6M_TOOLCHAIN_BUILDROOT=y
# CONFIG_ARMV6M_TOOLCHAIN_CODEREDL is not set
# CONFIG_ARMV6M_TOOLCHAIN_CODESOURCERYL is not set
CONFIG_ARMV6M_TOOLCHAIN_GNU_EABIL=y
# CONFIG_ARMV6M_TOOLCHAIN_GNU_EABIL is not set
# CONFIG_GPIO_IRQ is not set
#
@ -116,8 +117,8 @@ CONFIG_KL_UART0=y
# CONFIG_KL_UART2 is not set
# CONFIG_KL_FLEXCAN0 is not set
# CONFIG_KL_FLEXCAN1 is not set
CONFIG_KL_SPI0=y
CONFIG_KL_SPI1=y
# CONFIG_KL_SPI0 is not set
# CONFIG_KL_SPI1 is not set
# CONFIG_KL_SPI2 is not set
# CONFIG_KL_I2C0 is not set
# CONFIG_KL_I2C1 is not set
@ -281,11 +282,7 @@ CONFIG_DEV_NULL=y
# CONFIG_CAN is not set
# CONFIG_PWM is not set
# CONFIG_I2C is not set
CONFIG_SPI=y
# CONFIG_SPI_OWNBUS is not set
CONFIG_SPI_EXCHANGE=y
# CONFIG_SPI_CMDDATA is not set
# CONFIG_SPI_BITBANG is not set
# CONFIG_SPI is not set
# CONFIG_RTC is not set
# CONFIG_WATCHDOG is not set
# CONFIG_ANALOG is not set
@ -327,10 +324,7 @@ CONFIG_UART0_2STOP=0
# CONFIG_SERIAL_OFLOWCONTROL is not set
# CONFIG_USBDEV is not set
# CONFIG_USBHOST is not set
CONFIG_WIRELESS=y
# CONFIG_WL_CC1101 is not set
CONFIG_WL_CC3000=y
# CONFIG_WL_NRF24L01 is not set
# CONFIG_WIRELESS is not set
#
# System Logging Device Options
@ -446,7 +440,7 @@ CONFIG_BUILTIN_PROXY_STACKSIZE=1024
#
# CONFIG_EXAMPLES_BUTTONS is not set
# CONFIG_EXAMPLES_CAN is not set
CONFIG_EXAMPLES_CC3000BASIC=y
# CONFIG_EXAMPLES_CC3000BASIC is not set
# CONFIG_EXAMPLES_COMPOSITE is not set
# CONFIG_EXAMPLES_DHCPD is not set
# CONFIG_EXAMPLES_ELF is not set
@ -601,7 +595,7 @@ CONFIG_NSH_CONSOLE=y
# USB Trace Support
#
# CONFIG_NSH_CONDEV is not set
CONFIG_NSH_ARCHINIT=y
# CONFIG_NSH_ARCHINIT is not set
#
# NxWidgets/NxWM

2
configs/freedom-kl25z/src/kl_wifi.c
View File

@ -49,7 +49,7 @@
#include <nuttx/arch.h>
#include <nuttx/fs/fs.h>
#include <nuttx/cc3000/spi.h>
#include <nuttx/wireless/cc3000/spi.h>
#include "up_arch.h"
#include "kl_gpio.h"

1
drivers/Makefile
View File

@ -67,7 +67,6 @@ include syslog$(DELIM)Make.defs
include usbdev$(DELIM)Make.defs
include usbhost$(DELIM)Make.defs
include wireless$(DELIM)Make.defs
include wireless$(DELIM)cc3000$(DELIM)Make.defs
ifneq ($(CONFIG_NFILE_DESCRIPTORS),0)
CSRCS += dev_null.c dev_zero.c loop.c

4
drivers/wireless/Kconfig
View File

@ -13,6 +13,10 @@ menuconfig WL_CC3000
default n
select SPI
if WL_CC3000
source drivers/wireless/cc3000/Kconfig
endif
config WL_NRF24L01
bool "nRF24l01+ transceiver support"
default n

4
drivers/wireless/Make.defs
View File

@ -45,6 +45,10 @@ ifeq ($(CONFIG_WL_NRF24L01),y)
CSRCS += nrf24l01.c
endif
ifeq ($(CONFIG_WL_CC3000),y)
include wireless$(DELIM)cc3000$(DELIM)Make.defs
endif
# Include wireless devices build support
DEPPATH += --dep-path wireless

8
drivers/wireless/cc3000/cc3000_common.c
View File

@ -43,10 +43,10 @@
* Include files
*
*****************************************************************************/
#include <nuttx/cc3000/cc3000_common.h>
#include <nuttx/cc3000/socket.h>
#include <nuttx/cc3000/wlan.h>
#include <nuttx/cc3000/evnt_handler.h>
#include <nuttx/wireless/cc3000/cc3000_common.h>
#include <nuttx/wireless/cc3000/socket.h>
#include <nuttx/wireless/cc3000/wlan.h>
#include <nuttx/wireless/cc3000/evnt_handler.h>
//*****************************************************************************
//

14
drivers/wireless/cc3000/evnt_handler.c
View File

@ -44,13 +44,13 @@
//******************************************************************************
#include <string.h>
#include <nuttx/cc3000/cc3000_common.h>
#include <nuttx/cc3000/hci.h>
#include <nuttx/cc3000/evnt_handler.h>
#include <nuttx/cc3000/wlan.h>
#include <nuttx/cc3000/socket.h>
#include <nuttx/cc3000/netapp.h>
#include <nuttx/cc3000/spi.h>
#include <nuttx/wireless/cc3000/cc3000_common.h>
#include <nuttx/wireless/cc3000/hci.h>
#include <nuttx/wireless/cc3000/evnt_handler.h>
#include <nuttx/wireless/cc3000/wlan.h>
#include <nuttx/wireless/cc3000/socket.h>
#include <nuttx/wireless/cc3000/netapp.h>
#include <nuttx/wireless/cc3000/spi.h>

10
drivers/wireless/cc3000/hci.c
View File

@ -41,11 +41,11 @@
//*****************************************************************************
#include <string.h>
#include <nuttx/cc3000/cc3000_common.h>
#include <nuttx/cc3000/hci.h>
#include <nuttx/cc3000/spi.h>
#include <nuttx/cc3000/evnt_handler.h>
#include <nuttx/cc3000/wlan.h>
#include <nuttx/wireless/cc3000/cc3000_common.h>
#include <nuttx/wireless/cc3000/hci.h>
#include <nuttx/wireless/cc3000/spi.h>
#include <nuttx/wireless/cc3000/evnt_handler.h>
#include <nuttx/wireless/cc3000/wlan.h>
#define SL_PATCH_PORTION_SIZE (1000)

10
drivers/wireless/cc3000/netapp.c
View File

@ -33,11 +33,11 @@
*
*****************************************************************************/
#include <string.h>
#include <nuttx/cc3000/netapp.h>
#include <nuttx/cc3000/hci.h>
#include <nuttx/cc3000/socket.h>
#include <nuttx/cc3000/evnt_handler.h>
#include <nuttx/cc3000/nvmem.h>
#include <nuttx/wireless/cc3000/netapp.h>
#include <nuttx/wireless/cc3000/hci.h>
#include <nuttx/wireless/cc3000/socket.h>
#include <nuttx/wireless/cc3000/evnt_handler.h>
#include <nuttx/wireless/cc3000/nvmem.h>
#define MIN_TIMER_VAL_SECONDS 20
#define MIN_TIMER_SET(t) if ((0 != t) && (t < MIN_TIMER_VAL_SECONDS)) \

8
drivers/wireless/cc3000/nvmem.c
View File

@ -42,10 +42,10 @@
#include <stdio.h>
#include <string.h>
#include <nuttx/cc3000/nvmem.h>
#include <nuttx/cc3000/hci.h>
#include <nuttx/cc3000/socket.h>
#include <nuttx/cc3000/evnt_handler.h>
#include <nuttx/wireless/cc3000/nvmem.h>
#include <nuttx/wireless/cc3000/hci.h>
#include <nuttx/wireless/cc3000/socket.h>
#include <nuttx/wireless/cc3000/evnt_handler.h>
//*****************************************************************************
//

2
drivers/wireless/cc3000/security.c
View File

@ -40,7 +40,7 @@
//
//*****************************************************************************
#include <nuttx/cc3000/security.h>
#include <nuttx/wireless/cc3000/security.h>
#ifndef CC3000_UNENCRYPTED_SMART_CONFIG
// foreward sbox

8
drivers/wireless/cc3000/socket.c
View File

@ -43,10 +43,10 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <nuttx/cc3000/hci.h>
#include <nuttx/cc3000/socket.h>
#include <nuttx/cc3000/evnt_handler.h>
#include <nuttx/cc3000/netapp.h>
#include <nuttx/wireless/cc3000/hci.h>
#include <nuttx/wireless/cc3000/socket.h>
#include <nuttx/wireless/cc3000/evnt_handler.h>
#include <nuttx/wireless/cc3000/netapp.h>

681
drivers/wireless/cc3000/spi.c
View File

@ -5,9 +5,9 @@
* This code uses the Arduino hardware SPI library (or a bit-banged
* SPI for the Teensy 3.0) to send & receive data between the library
* API calls and the CC3000 hardware. Every
*
*
* Version 1.0.1b
*
*
* Copyright (C) 2013 Chris Magagna - cmagagna@yahoo.com
*
* Redistribution and use in source and binary forms, with or without
@ -25,9 +25,9 @@
#include <nuttx/config.h>
#include <nuttx/spi/spi.h>
#include <arch/board/kl_wifi.h>
#include <nuttx/cc3000/hci.h>
#include <nuttx/cc3000/spi.h>
//#include <nuttx/cc3000/ArduinoCC3000Core.h>
#include <nuttx/wireless/cc3000/hci.h>
#include <nuttx/wireless/cc3000/spi.h>
//#include <nuttx/wireless/cc3000/ArduinoCC3000Core.h>
// This flag lets the interrupt handler know if it should respond to
// the WL_SPI_IRQ pin going low or not
@ -42,17 +42,17 @@ int16_t SPIInterruptsEnabled=0;
#define HEADERS_SIZE_EVNT (SPI_HEADER_SIZE + 5)
#define SPI_HEADER_SIZE (5)
#define SPI_HEADER_SIZE (5)
#define eSPI_STATE_POWERUP (0)
#define eSPI_STATE_INITIALIZED (1)
#define eSPI_STATE_IDLE (2)
#define eSPI_STATE_WRITE_IRQ (3)
#define eSPI_STATE_WRITE_FIRST_PORTION (4)
#define eSPI_STATE_WRITE_EOT (5)
#define eSPI_STATE_READ_IRQ (6)
#define eSPI_STATE_READ_FIRST_PORTION (7)
#define eSPI_STATE_READ_EOT (8)
#define eSPI_STATE_POWERUP (0)
#define eSPI_STATE_INITIALIZED (1)
#define eSPI_STATE_IDLE (2)
#define eSPI_STATE_WRITE_IRQ (3)
#define eSPI_STATE_WRITE_FIRST_PORTION (4)
#define eSPI_STATE_WRITE_EOT (5)
#define eSPI_STATE_READ_IRQ (6)
#define eSPI_STATE_READ_FIRST_PORTION (7)
#define eSPI_STATE_READ_EOT (8)
/* !!!HACK!!!*/
#define KL_PORTA_ISFR 0x400490a0
@ -60,7 +60,6 @@ int16_t SPIInterruptsEnabled=0;
#define getreg32(a) (*(volatile uint32_t *)(a))
#define putreg32(v,a) (*(volatile uint32_t *)(a) = (v))
#undef SPI_DEBUG /* Define to enable debug */
#undef SPI_VERBOSE /* Define to enable verbose debug */
@ -77,7 +76,6 @@ int16_t SPIInterruptsEnabled=0;
# define spivdbg(x...)
#endif
#ifdef CONFIG_KL_SPI0
void kl_spi0select(FAR struct spi_dev_s *dev, enum spi_dev_e devid,
bool selected)
@ -96,7 +94,6 @@ void kl_spi1select(FAR struct spi_dev_s *dev, enum spi_dev_e devid,
}
#endif
#ifdef CONFIG_KL_SPI0
uint8_t kl_spi0status(FAR struct spi_dev_s *dev, enum spi_dev_e devid)
{
@ -111,20 +108,17 @@ uint8_t kl_spi1status(FAR struct spi_dev_s *dev, enum spi_dev_e devid)
}
#endif
typedef struct
{
gcSpiHandleRx SPIRxHandler;
gcSpiHandleRx SPIRxHandler;
uint16_t usTxPacketLength;
uint16_t usRxPacketLength;
unsigned long ulSpiState;
uint8_t *pTxPacket;
uint8_t *pRxPacket;
}tSpiInformation;
uint16_t usTxPacketLength;
uint16_t usRxPacketLength;
unsigned long ulSpiState;
uint8_t *pTxPacket;
uint8_t *pRxPacket;
} tSpiInformation;
tSpiInformation sSpiInformation;
@ -133,9 +127,8 @@ tSpiInformation sSpiInformation;
//
uint8_t tSpiReadHeader[] = {READ, 0, 0, 0, 0};
// The magic number that resides at the end of the TX/RX buffer (1 byte after the allocated size)
// for the purpose of detection of the overrun. The location of the memory where the magic number
// for the purpose of detection of the overrun. The location of the memory where the magic number
// resides shall never be written. In case it is written - the overrun occured and either recevie function
// or send function will stuck forever.
#define CC3000_BUFFER_MAGIC_NUMBER (0xDE)
@ -147,24 +140,24 @@ struct spi_dev_s *spi = NULL;
unsigned int SPIPump(uint8_t data)
{
uint8_t rx;
uint8_t rx;
printf("SPIPump tx = 0x%X ", data);
printf("SPIPump tx = 0x%X ", data);
if(!spi){
spi = up_spiinitialize(1);
SPI_SETBITS(spi, 8);
SPI_SETMODE(spi, SPIDEV_MODE1);
}
if (!spi)
{
spi = up_spiinitialize(1);
SPI_SETBITS(spi, 8);
SPI_SETMODE(spi, SPIDEV_MODE1);
}
SPI_EXCHANGE(spi, &data, &rx, 1);
SPI_EXCHANGE(spi, &data, &rx, 1);
printf(" rx = 0x%X\n", rx);
return rx;
printf(" rx = 0x%X\n", rx);
return rx;
}
//*****************************************************************************
//
//! This function enter point for write flow
@ -173,16 +166,15 @@ unsigned int SPIPump(uint8_t data)
//!
//! \return none
//!
//! \brief The function triggers a user provided callback for
//! \brief The function triggers a user provided callback for
//
//*****************************************************************************
void SpiPauseSpi(void)
{
SPIInterruptsEnabled = 0;
SPIInterruptsEnabled = 0;
}
//*****************************************************************************
//
//! This function enter point for write flow
@ -191,16 +183,15 @@ void SpiPauseSpi(void)
//!
//! \return none
//!
//! \brief The function triggers a user provided callback for
//! \brief The function triggers a user provided callback for
//
//*****************************************************************************
void SpiResumeSpi(void)
{
SPIInterruptsEnabled = 1;
SPIInterruptsEnabled = 1;
}
//*****************************************************************************
//
//! This function enter point for write flow
@ -209,30 +200,30 @@ void SpiResumeSpi(void)
//!
//! \return none
//!
//! \brief The function triggers a user provided callback for
//! \brief The function triggers a user provided callback for
//
//*****************************************************************************
void SpiTriggerRxProcessing(void)
{
//
// Trigger Rx processing
//
SpiPauseSpi();
DeassertWlanCS();
// The magic number that resides at the end of the TX/RX buffer (1 byte after the allocated size)
// for the purpose of detection of the overrun. If the magic number is overriten - buffer overrun
// occurred - and we will stuck here forever!
if (sSpiInformation.pRxPacket[CC3000_RX_BUFFER_SIZE - 1] != CC3000_BUFFER_MAGIC_NUMBER)
{
while (1)
;
}
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
sSpiInformation.SPIRxHandler(sSpiInformation.pRxPacket + SPI_HEADER_SIZE);
}
//
// Trigger Rx processing
//
SpiPauseSpi();
DeassertWlanCS();
// The magic number that resides at the end of the TX/RX buffer (1 byte after the allocated size)
// for the purpose of detection of the overrun. If the magic number is overriten - buffer overrun
// occurred - and we will stuck here forever!
if (sSpiInformation.pRxPacket[CC3000_RX_BUFFER_SIZE - 1] != CC3000_BUFFER_MAGIC_NUMBER)
{
while (1)
;
}
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
sSpiInformation.SPIRxHandler(sSpiInformation.pRxPacket + SPI_HEADER_SIZE);
}
//*****************************************************************************
//
@ -245,16 +236,17 @@ void SpiTriggerRxProcessing(void)
//! \brief ...
//
//*****************************************************************************
void SpiReadDataSynchronous(uint8_t *data, uint16_t size)
{
long i = 0;
long i = 0;
uint8_t *data_to_send = tSpiReadHeader;
for (i = 0; i < size; i ++) {
data[i] = SPIPump(data_to_send[0]);
}
}
for (i = 0; i < size; i ++)
{
data[i] = SPIPump(data_to_send[0]);
}
}
//*****************************************************************************
//
@ -267,18 +259,17 @@ void SpiReadDataSynchronous(uint8_t *data, uint16_t size)
//! \brief ...
//
//*****************************************************************************
void SpiWriteDataSynchronous(uint8_t *data, uint16_t size)
{
while (size)
{
SPIPump(*data);
size --;
data++;
}
while (size)
{
SPIPump(*data);
size --;
data++;
}
}
//*****************************************************************************
//
//! This function enter point for write flow
@ -292,31 +283,31 @@ void SpiWriteDataSynchronous(uint8_t *data, uint16_t size)
//*****************************************************************************
long SpiFirstWrite(uint8_t *ucBuf, uint16_t usLength)
{
//
// workaround for first transaction
//
int i = 0, j = 1;
AssertWlanCS();
usleep(70);
// SPI writes first 4 bytes of data
SpiWriteDataSynchronous(ucBuf, 4);
usleep(70);
SpiWriteDataSynchronous(ucBuf + 4, usLength - 4);
//
// workaround for first transaction
//
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
DeassertWlanCS();
AssertWlanCS();
//printf("Executed SpiFirstWrite!\n");
usleep(70);
return(0);
// SPI writes first 4 bytes of data
SpiWriteDataSynchronous(ucBuf, 4);
usleep(70);
SpiWriteDataSynchronous(ucBuf + 4, usLength - 4);
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
DeassertWlanCS();
//printf("Executed SpiFirstWrite!\n");
return(0);
}
//*****************************************************************************
//
//! This function enter point for write flow
@ -328,109 +319,114 @@ long SpiFirstWrite(uint8_t *ucBuf, uint16_t usLength)
//! \brief ...
//
//*****************************************************************************
long SpiWrite(uint8_t *pUserBuffer, uint16_t usLength)
{
uint8_t ucPad = 0;
//
// Figure out the total length of the packet in order to figure out if there is padding or not
//
if(!(usLength & 0x0001))
uint8_t ucPad = 0;
//
// Figure out the total length of the packet in order to figure out if there is padding or not
//
if(!(usLength & 0x0001))
{
ucPad++;
ucPad++;
}
pUserBuffer[0] = WRITE;
pUserBuffer[1] = HI(usLength + ucPad);
pUserBuffer[2] = LO(usLength + ucPad);
pUserBuffer[3] = 0;
pUserBuffer[4] = 0;
usLength += (SPI_HEADER_SIZE + ucPad);
// The magic number that resides at the end of the TX/RX buffer (1 byte after the allocated size)
// for the purpose of overrun detection. If the magic number is overwritten - buffer overrun
// occurred - and we will be stuck here forever!
if (wlan_tx_buffer[CC3000_TX_BUFFER_SIZE - 1] != CC3000_BUFFER_MAGIC_NUMBER)
{
while (1)
;
}
if (sSpiInformation.ulSpiState == eSPI_STATE_POWERUP)
{
while (sSpiInformation.ulSpiState != eSPI_STATE_INITIALIZED)
{
}
}
if (sSpiInformation.ulSpiState == eSPI_STATE_INITIALIZED)
{
//
// This is time for first TX/RX transactions over SPI:
// the IRQ is down - so need to send read buffer size command
//
SpiFirstWrite(pUserBuffer, usLength);
}
else
{
//
// We need to prevent here race that can occur in case two back to back packets are sent to the
// device, so the state will move to IDLE and once again to not IDLE due to IRQ
//
tSLInformation.WlanInterruptDisable();
while (sSpiInformation.ulSpiState != eSPI_STATE_IDLE)
{
;
}
sSpiInformation.ulSpiState = eSPI_STATE_WRITE_IRQ;
sSpiInformation.pTxPacket = pUserBuffer;
sSpiInformation.usTxPacketLength = usLength;
//
// Assert the CS line and wait till SSI IRQ line is active and then initialize write operation
//
AssertWlanCS();
//
// Re-enable IRQ - if it was not disabled - this is not a problem...
//
tSLInformation.WlanInterruptEnable();
//
// check for a missing interrupt between the CS assertion and enabling back the interrupts
//
if (tSLInformation.ReadWlanInterruptPin() == 0)
{
SpiWriteDataSynchronous(sSpiInformation.pTxPacket, sSpiInformation.usTxPacketLength);
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
DeassertWlanCS();
}
}
pUserBuffer[0] = WRITE;
pUserBuffer[1] = HI(usLength + ucPad);
pUserBuffer[2] = LO(usLength + ucPad);
pUserBuffer[3] = 0;
pUserBuffer[4] = 0;
//
// Due to the fact that we are currently implementing a blocking situation
// here we will wait till end of transaction
//
usLength += (SPI_HEADER_SIZE + ucPad);
// The magic number that resides at the end of the TX/RX buffer (1 byte after the allocated size)
// for the purpose of overrun detection. If the magic number is overwritten - buffer overrun
// occurred - and we will be stuck here forever!
if (wlan_tx_buffer[CC3000_TX_BUFFER_SIZE - 1] != CC3000_BUFFER_MAGIC_NUMBER)
{
while (1)
;
}
if (sSpiInformation.ulSpiState == eSPI_STATE_POWERUP)
{
while (sSpiInformation.ulSpiState != eSPI_STATE_INITIALIZED) {
}
;
}
if (sSpiInformation.ulSpiState == eSPI_STATE_INITIALIZED)
{
//
// This is time for first TX/RX transactions over SPI:
// the IRQ is down - so need to send read buffer size command
//
SpiFirstWrite(pUserBuffer, usLength);
}
else
{
//
// We need to prevent here race that can occur in case two back to back packets are sent to the
// device, so the state will move to IDLE and once again to not IDLE due to IRQ
//
tSLInformation.WlanInterruptDisable();
while (eSPI_STATE_IDLE != sSpiInformation.ulSpiState)
;
while (sSpiInformation.ulSpiState != eSPI_STATE_IDLE)
{
;
}
sSpiInformation.ulSpiState = eSPI_STATE_WRITE_IRQ;
sSpiInformation.pTxPacket = pUserBuffer;
sSpiInformation.usTxPacketLength = usLength;
//
// Assert the CS line and wait till SSI IRQ line is active and then initialize write operation
//
AssertWlanCS();
//
// Re-enable IRQ - if it was not disabled - this is not a problem...
//
tSLInformation.WlanInterruptEnable();
//
// check for a missing interrupt between the CS assertion and enabling back the interrupts
//
if (tSLInformation.ReadWlanInterruptPin() == 0)
{
SpiWriteDataSynchronous(sSpiInformation.pTxPacket, sSpiInformation.usTxPacketLength);
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
DeassertWlanCS();
}
}
//
// Due to the fact that we are currently implementing a blocking situation
// here we will wait till end of transaction
//
while (eSPI_STATE_IDLE != sSpiInformation.ulSpiState)
;
return(0);
return(0);
}
//*****************************************************************************
//
//! This function processes received SPI Header and in accordance with it - continues reading
//! the packet
//! This function processes received SPI Header and in accordance with it - continues reading
//! the packet
//!
//! \param None
//!
@ -439,69 +435,74 @@ long SpiWrite(uint8_t *pUserBuffer, uint16_t usLength)
//! \brief ...
//
//*****************************************************************************
long SpiReadDataCont(void)
{
long data_to_recv;
uint8_t *evnt_buff, type;
long data_to_recv;
uint8_t *evnt_buff, type;
//
//determine what type of packet we have
//
evnt_buff = sSpiInformation.pRxPacket;
data_to_recv = 0;
STREAM_TO_UINT8((char *)(evnt_buff + SPI_HEADER_SIZE), HCI_PACKET_TYPE_OFFSET, type);
switch(type)
//
//determine what type of packet we have
//
evnt_buff = sSpiInformation.pRxPacket;
data_to_recv = 0;
STREAM_TO_UINT8((char *)(evnt_buff + SPI_HEADER_SIZE), HCI_PACKET_TYPE_OFFSET, type);
switch(type)
{
case HCI_TYPE_DATA:
case HCI_TYPE_DATA:
{
//
// We need to read the rest of data..
//
STREAM_TO_UINT16((char *)(evnt_buff + SPI_HEADER_SIZE), HCI_DATA_LENGTH_OFFSET, data_to_recv);
if (!((HEADERS_SIZE_EVNT + data_to_recv) & 1))
{
data_to_recv++;
}
//
// We need to read the rest of data..
//
if (data_to_recv)
{
SpiReadDataSynchronous(evnt_buff + 10, data_to_recv);
}
break;
STREAM_TO_UINT16((char *)(evnt_buff + SPI_HEADER_SIZE), HCI_DATA_LENGTH_OFFSET, data_to_recv);
if (!((HEADERS_SIZE_EVNT + data_to_recv) & 1))
{
data_to_recv++;
}
if (data_to_recv)
{
SpiReadDataSynchronous(evnt_buff + 10, data_to_recv);
}
break;
}
case HCI_TYPE_EVNT:
{
//
// Calculate the rest length of the data
//
STREAM_TO_UINT8((char *)(evnt_buff + SPI_HEADER_SIZE), HCI_EVENT_LENGTH_OFFSET, data_to_recv);
data_to_recv -= 1;
//
// Add padding byte if needed
//
if ((HEADERS_SIZE_EVNT + data_to_recv) & 1)
{
data_to_recv++;
}
if (data_to_recv)
{
SpiReadDataSynchronous(evnt_buff + 10, data_to_recv);
}
sSpiInformation.ulSpiState = eSPI_STATE_READ_EOT;
break;
case HCI_TYPE_EVNT:
{
//
// Calculate the rest length of the data
//
STREAM_TO_UINT8((char *)(evnt_buff + SPI_HEADER_SIZE), HCI_EVENT_LENGTH_OFFSET, data_to_recv);
data_to_recv -= 1;
//
// Add padding byte if needed
//
if ((HEADERS_SIZE_EVNT + data_to_recv) & 1)
{
data_to_recv++;
}
if (data_to_recv)
{
SpiReadDataSynchronous(evnt_buff + 10, data_to_recv);
}
sSpiInformation.ulSpiState = eSPI_STATE_READ_EOT;
break;
}
}
return (0);
}
//*****************************************************************************
//
//! This function enter point for write flow
@ -510,32 +511,30 @@ long SpiReadDataCont(void)
//!
//! \return none
//!
//! \brief The function triggers a user provided callback for
//! \brief The function triggers a user provided callback for
//
//*****************************************************************************
void SSIContReadOperation(void)
{
//
// The header was read - continue with the payload read
//
if (!SpiReadDataCont())
{
//
// All the data was read - finalize handling by switching to teh task
// and calling from task Event Handler
//
SpiTriggerRxProcessing();
}
}
//
// The header was read - continue with the payload read
//
if (!SpiReadDataCont())
{
//
// All the data was read - finalize handling by switching to teh task
// and calling from task Event Handler
//
SpiTriggerRxProcessing();
}
}
//*****************************************************************************
//
//! This function enter point for read flow: first we read minimal 5 SPI header bytes and 5 Event
//! Data bytes
//! Data bytes
//!
//! \param buffer
//!
@ -546,82 +545,84 @@ void SSIContReadOperation(void)
//*****************************************************************************
void SpiReadHeader(void)
{
SpiReadDataSynchronous(sSpiInformation.pRxPacket, 10);
SpiReadDataSynchronous(sSpiInformation.pRxPacket, 10);
}
//*****************************************************************************
//
//
//! The IntSpiGPIOHandler interrupt handler
//!
//!
//! \param none
//!
//!
//! \return none
//!
//!
//! \brief GPIO A interrupt handler. When the external SSI WLAN device is
//! ready to interact with Host CPU it generates an interrupt signal.
//! After that Host CPU has registrated this interrupt request
//! it set the corresponding /CS in active state.
//
//
//*****************************************************************************
//#pragma vector=PORT2_VECTOR
//__interrupt void IntSpiGPIOHandler(void)
int CC3000InterruptHandler(int irq, void *context)
{
uint32_t regval = 0;
uint32_t regval = 0;
regval = getreg32(KL_PORTA_ISFR);
if (regval & (1 << PIN16))
{
//printf("\nAn interrupt was issued!\n");
regval = getreg32(KL_PORTA_ISFR);
if (regval & (1 << PIN16))
if (!SPIInterruptsEnabled)
{
//printf("\nAn interrupt was issued!\n");
if (!SPIInterruptsEnabled) {
goto out;
}
//printf("\nSPIInterrupt was enabled!\n");
if (sSpiInformation.ulSpiState == eSPI_STATE_POWERUP)
{
/* This means IRQ line was low call a callback of HCI Layer to inform on event */
sSpiInformation.ulSpiState = eSPI_STATE_INITIALIZED;
}
else if (sSpiInformation.ulSpiState == eSPI_STATE_IDLE)
{
sSpiInformation.ulSpiState = eSPI_STATE_READ_IRQ;
/* IRQ line goes down - start reception */
AssertWlanCS();
//
// Wait for TX/RX Complete which will come as DMA interrupt
//
SpiReadHeader();
sSpiInformation.ulSpiState = eSPI_STATE_READ_EOT;
SSIContReadOperation();
}
else if (sSpiInformation.ulSpiState == eSPI_STATE_WRITE_IRQ)
{
SpiWriteDataSynchronous(sSpiInformation.pTxPacket, sSpiInformation.usTxPacketLength);
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
DeassertWlanCS();
}
else {
}
out:
regval = (1 << PIN16);
putreg32(regval, KL_PORTA_ISFR);
goto out;
}
return 0;
}
//printf("\nSPIInterrupt was enabled!\n");
if (sSpiInformation.ulSpiState == eSPI_STATE_POWERUP)
{
/* This means IRQ line was low call a callback of HCI Layer to inform on event */
sSpiInformation.ulSpiState = eSPI_STATE_INITIALIZED;
}
else if (sSpiInformation.ulSpiState == eSPI_STATE_IDLE)
{
sSpiInformation.ulSpiState = eSPI_STATE_READ_IRQ;
/* IRQ line goes down - start reception */
AssertWlanCS();
//
// Wait for TX/RX Complete which will come as DMA interrupt
//
SpiReadHeader();
sSpiInformation.ulSpiState = eSPI_STATE_READ_EOT;
SSIContReadOperation();
}
else if (sSpiInformation.ulSpiState == eSPI_STATE_WRITE_IRQ)
{
SpiWriteDataSynchronous(sSpiInformation.pTxPacket, sSpiInformation.usTxPacketLength);
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
DeassertWlanCS();
}
else
{
}
out:
regval = (1 << PIN16);
putreg32(regval, KL_PORTA_ISFR);
}
return 0;
}
//*****************************************************************************
//
@ -634,29 +635,28 @@ out:
//! \brief Cofigure the SSI
//
//*****************************************************************************
void SpiOpen(gcSpiHandleRx pfRxHandler)
{
sSpiInformation.ulSpiState = eSPI_STATE_POWERUP;
memset(spi_buffer, 0, sizeof(spi_buffer));
memset(wlan_tx_buffer, 0, sizeof(spi_buffer));
sSpiInformation.ulSpiState = eSPI_STATE_POWERUP;
sSpiInformation.SPIRxHandler = pfRxHandler;
sSpiInformation.usTxPacketLength = 0;
sSpiInformation.pTxPacket = NULL;
sSpiInformation.pRxPacket = (uint8_t *)spi_buffer;
sSpiInformation.usRxPacketLength = 0;
spi_buffer[CC3000_RX_BUFFER_SIZE - 1] = CC3000_BUFFER_MAGIC_NUMBER;
wlan_tx_buffer[CC3000_TX_BUFFER_SIZE - 1] = CC3000_BUFFER_MAGIC_NUMBER;
memset(spi_buffer, 0, sizeof(spi_buffer));
memset(wlan_tx_buffer, 0, sizeof(spi_buffer));
//
// Enable interrupt on the GPIO pin of WLAN IRQ
//
tSLInformation.WlanInterruptEnable();
sSpiInformation.SPIRxHandler = pfRxHandler;
sSpiInformation.usTxPacketLength = 0;
sSpiInformation.pTxPacket = NULL;
sSpiInformation.pRxPacket = (uint8_t *)spi_buffer;
sSpiInformation.usRxPacketLength = 0;
spi_buffer[CC3000_RX_BUFFER_SIZE - 1] = CC3000_BUFFER_MAGIC_NUMBER;
wlan_tx_buffer[CC3000_TX_BUFFER_SIZE - 1] = CC3000_BUFFER_MAGIC_NUMBER;
//
// Enable interrupt on the GPIO pin of WLAN IRQ
//
tSLInformation.WlanInterruptEnable();
}
//*****************************************************************************
//
//! SpiClose
@ -668,16 +668,17 @@ void SpiOpen(gcSpiHandleRx pfRxHandler)
//! \brief Cofigure the SSI
//
//*****************************************************************************
void SpiClose(void)
{
if (sSpiInformation.pRxPacket)
{
sSpiInformation.pRxPacket = 0;
}
if (sSpiInformation.pRxPacket)
{
sSpiInformation.pRxPacket = 0;
}
//
// Disable Interrupt in GPIOA module...
//
tSLInformation.WlanInterruptDisable();
//
// Disable Interrupt in GPIOA module...
//
tSLInformation.WlanInterruptDisable();
}

14
drivers/wireless/cc3000/wlan.c
View File

@ -40,13 +40,13 @@
//
//*****************************************************************************
#include <string.h>
#include <nuttx/cc3000/wlan.h>
#include <nuttx/cc3000/hci.h>
#include <nuttx/cc3000/spi.h>
#include <nuttx/cc3000/socket.h>
#include <nuttx/cc3000/nvmem.h>
#include <nuttx/cc3000/security.h>
#include <nuttx/cc3000/evnt_handler.h>
#include <nuttx/wireless/cc3000/wlan.h>
#include <nuttx/wireless/cc3000/hci.h>
#include <nuttx/wireless/cc3000/spi.h>
#include <nuttx/wireless/cc3000/socket.h>
#include <nuttx/wireless/cc3000/nvmem.h>
#include <nuttx/wireless/cc3000/security.h>
#include <nuttx/wireless/cc3000/evnt_handler.h>
volatile sSimplLinkInformation tSLInformation;

0
include/nuttx/cc3000/cc3000_common.h → include/nuttx/wireless/cc3000/cc3000_common.h
View File

5
include/nuttx/cc3000/evnt_handler.h → include/nuttx/wireless/cc3000/evnt_handler.h
View File

@ -34,8 +34,9 @@
*****************************************************************************/
#ifndef __EVENT_HANDLER_H__
#define __EVENT_HANDLER_H__
#include "hci.h"
#include "socket.h"
#include <nuttx/wireless/cc3000/hci.h>
#include <nuttx/wireless/cc3000/socket.h>
//*****************************************************************************
//

2
include/nuttx/cc3000/hci.h → include/nuttx/wireless/cc3000/hci.h
View File

@ -35,7 +35,7 @@
#ifndef __HCI_H__
#define __HCI_H__
#include "cc3000_common.h"
#include <nuttx/wireless/cc3000/cc3000_common.h>
//*****************************************************************************
//

0
include/nuttx/cc3000/host_driver_version.h → include/nuttx/wireless/cc3000/host_driver_version.h
View File

0
include/nuttx/cc3000/netapp.h → include/nuttx/wireless/cc3000/netapp.h
View File

2
include/nuttx/cc3000/nvmem.h → include/nuttx/wireless/cc3000/nvmem.h
View File

@ -35,7 +35,7 @@
#ifndef __NVRAM_H__
#define __NVRAM_H__
#include "cc3000_common.h"
#include <nuttx/wireless/cc3000/cc3000_common.h>
//*****************************************************************************

2
include/nuttx/cc3000/security.h → include/nuttx/wireless/cc3000/security.h
View File

@ -35,7 +35,7 @@
#ifndef __SECURITY__
#define __SECURITY__
#include "nvmem.h"
#include <nuttx/wireless/cc3000/nvmem.h>
//*****************************************************************************
//

0
include/nuttx/cc3000/socket.h → include/nuttx/wireless/cc3000/socket.h
View File

0
include/nuttx/cc3000/spi.h → include/nuttx/wireless/cc3000/spi.h
View File

0
include/nuttx/cc3000/spi_version.h → include/nuttx/wireless/cc3000/spi_version.h
View File

2
include/nuttx/cc3000/wlan.h → include/nuttx/wireless/cc3000/wlan.h
View File

@ -35,7 +35,7 @@
#ifndef __WLAN_H__
#define __WLAN_H__
#include "cc3000_common.h"
#include <nuttx/wireless/cc3000/cc3000_common.h>
//*****************************************************************************
//