Some restructing of the CC3000 build

12 files changed, 396 insertions, 388 deletions

diff --git a/nuttx/drivers/Makefile b/nuttx/drivers/Makefile
index 56d02bfce..cce03cad0 100644
--- a/nuttx/drivers/Makefile
+++ b/nuttx/drivers/Makefile
@@ -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
diff --git a/nuttx/drivers/wireless/Kconfig b/nuttx/drivers/wireless/Kconfig
index 5e6c0d386..bb2b366f7 100644
--- a/nuttx/drivers/wireless/Kconfig
+++ b/nuttx/drivers/wireless/Kconfig
@@ -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
diff --git a/nuttx/drivers/wireless/Make.defs b/nuttx/drivers/wireless/Make.defs
index 3e7126acc..b75c48764 100644
--- a/nuttx/drivers/wireless/Make.defs
+++ b/nuttx/drivers/wireless/Make.defs
@@ -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
diff --git a/nuttx/drivers/wireless/cc3000/cc3000_common.c b/nuttx/drivers/wireless/cc3000/cc3000_common.c
index dae74d4c4..75a6ded4b 100644
--- a/nuttx/drivers/wireless/cc3000/cc3000_common.c
+++ b/nuttx/drivers/wireless/cc3000/cc3000_common.c
@@ -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>
 
 //*****************************************************************************
 //
diff --git a/nuttx/drivers/wireless/cc3000/evnt_handler.c b/nuttx/drivers/wireless/cc3000/evnt_handler.c
index f430c820e..ffc3ae6cd 100644
--- a/nuttx/drivers/wireless/cc3000/evnt_handler.c
+++ b/nuttx/drivers/wireless/cc3000/evnt_handler.c
@@ -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>
 
  
 
diff --git a/nuttx/drivers/wireless/cc3000/hci.c b/nuttx/drivers/wireless/cc3000/hci.c
index c238b2772..033f1e7cd 100644
--- a/nuttx/drivers/wireless/cc3000/hci.c
+++ b/nuttx/drivers/wireless/cc3000/hci.c
@@ -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)
 
diff --git a/nuttx/drivers/wireless/cc3000/netapp.c b/nuttx/drivers/wireless/cc3000/netapp.c
index fe00a7254..4bdd205db 100644
--- a/nuttx/drivers/wireless/cc3000/netapp.c
+++ b/nuttx/drivers/wireless/cc3000/netapp.c
@@ -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)) \
diff --git a/nuttx/drivers/wireless/cc3000/nvmem.c b/nuttx/drivers/wireless/cc3000/nvmem.c
index 66c9cb850..779d4304e 100644
--- a/nuttx/drivers/wireless/cc3000/nvmem.c
+++ b/nuttx/drivers/wireless/cc3000/nvmem.c
@@ -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>
 
 //*****************************************************************************
 //
diff --git a/nuttx/drivers/wireless/cc3000/security.c b/nuttx/drivers/wireless/cc3000/security.c
index c364c68d7..e37d9a0de 100644
--- a/nuttx/drivers/wireless/cc3000/security.c
+++ b/nuttx/drivers/wireless/cc3000/security.c
@@ -40,7 +40,7 @@
 //
 //*****************************************************************************
 
-#include <nuttx/cc3000/security.h>
+#include <nuttx/wireless/cc3000/security.h>
 
 #ifndef CC3000_UNENCRYPTED_SMART_CONFIG
 // foreward sbox
diff --git a/nuttx/drivers/wireless/cc3000/socket.c b/nuttx/drivers/wireless/cc3000/socket.c
index 5b810f231..8e6c873ff 100644
--- a/nuttx/drivers/wireless/cc3000/socket.c
+++ b/nuttx/drivers/wireless/cc3000/socket.c
@@ -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>
 
 
 
diff --git a/nuttx/drivers/wireless/cc3000/spi.c b/nuttx/drivers/wireless/cc3000/spi.c
index 47e809bba..78582cc62 100644
--- a/nuttx/drivers/wireless/cc3000/spi.c
+++ b/nuttx/drivers/wireless/cc3000/spi.c
@@ -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,23 +140,23 @@ 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;
+}
 
 //*****************************************************************************
 //
@@ -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,30 +283,30 @@ 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);
-
-    sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
-    
-    DeassertWlanCS();
-
-    //printf("Executed SpiFirstWrite!\n");
-
-    return(0);
-}
+  //
+  // workaround for first transaction
+  //
+
+  AssertWlanCS();
+
+  usleep(70);
+
+  // 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);
+}
 
 //*****************************************************************************
 //
@@ -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;
 
-    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();
-		}
-	}
-
-
-	//
-	// 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);
-}
+  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();
+        }
+    }
+
+
+  //
+  // 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);
+}
 
 //*****************************************************************************
 //
-//! 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;
-
-	
-    //
-    //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)
+  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)
     {
-        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++;
-			}
-
-			if (data_to_recv)
-			{
-            	SpiReadDataSynchronous(evnt_buff + 10, data_to_recv);
-			}
-            break;
+          //
+          // 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++;
+            }
+
+          if (data_to_recv)
+            {
+              SpiReadDataSynchronous(evnt_buff + 10, data_to_recv);
+            }
+          break;
         }
-        case HCI_TYPE_EVNT:
+
+      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;
+          //
+          // 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.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();
-	
+  sSpiInformation.ulSpiState = eSPI_STATE_POWERUP;
+
+  memset(spi_buffer, 0, sizeof(spi_buffer));
+  memset(wlan_tx_buffer, 0, sizeof(spi_buffer));
+
+  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;
-	}
-
-	//
-	//	Disable Interrupt in GPIOA module...
-	//
-    tSLInformation.WlanInterruptDisable();
-}
+  if (sSpiInformation.pRxPacket)
+    {
+      sSpiInformation.pRxPacket = 0;
+    }
 
+  //
+  //  Disable Interrupt in GPIOA module...
+  //
+
+  tSLInformation.WlanInterruptDisable();
+}
diff --git a/nuttx/drivers/wireless/cc3000/wlan.c b/nuttx/drivers/wireless/cc3000/wlan.c
index 48735947b..38f8f2b70 100644
--- a/nuttx/drivers/wireless/cc3000/wlan.c
+++ b/nuttx/drivers/wireless/cc3000/wlan.c
@@ -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;