Numerous updates to the CC3000 driver from David Sidrane

8 files changed, 209 insertions, 83 deletions

diff --git a/nuttx/drivers/wireless/cc3000/cc3000.c b/nuttx/drivers/wireless/cc3000/cc3000.c
index b051578cc..674be5c28 100644
--- a/nuttx/drivers/wireless/cc3000/cc3000.c
+++ b/nuttx/drivers/wireless/cc3000/cc3000.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/wireless/cc3000.c
  *
- *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2014 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            David_s5 <david_s5@nscdg.com>
  *
@@ -80,11 +80,13 @@
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
-
-#if CC3000_RX_BUFFER_SIZE > CONFIG_MQ_MAXMSGSIZE
-#error "CONFIG_MQ_MAXMSGSIZE needs to be >= CC3000_RX_BUFFER_SIZE"
+#ifndef CCASSERT
+#define CCASSERT(predicate) _x_CCASSERT_LINE(predicate, __LINE__)
+#define _x_CCASSERT_LINE(predicate, line) typedef char constraint_violated_on_line_##line[2*((predicate)!=0)-1];
 #endif
 
+CCASSERT(sizeof(cc3000_buffer_desc) <= CONFIG_MQ_MAXMSGSIZE);
+
 #ifndef CONFIG_CC3000_WORKER_THREAD_PRIORITY
 #  define CONFIG_CC3000_WORKER_THREAD_PRIORITY (SCHED_PRIORITY_MAX)
 #endif
@@ -94,7 +96,7 @@
 #endif
 
 #ifndef CONFIG_CC3000_SELECT_THREAD_PRIORITY
-#  define CONFIG_CC3000_SELECT_THREAD_PRIORITY (SCHED_PRIORITY_DEFAULT+10)
+#  define CONFIG_CC3000_SELECT_THREAD_PRIORITY (SCHED_PRIORITY_DEFAULT-1)
 #endif
 
 #ifndef CONFIG_CC3000_SELECT_STACKSIZE
@@ -107,6 +109,7 @@
 #define NUMBER_OF_MSGS 1
 
 #define FREE_SLOT -1
+#define CLOSE_SLOT -2
 
 #if defined(CONFIG_CC3000_PROBES)
 #  define CC3000_GUARD (0xc35aa53c)
@@ -119,6 +122,8 @@
 #  define PROBE(pin,state)
 #endif
 
+#define waitlldbg(x,...)
+
 /****************************************************************************
  * Private Types
  ****************************************************************************/
@@ -265,7 +270,7 @@ static void usdelay(long ustimeout)
 
 static inline void cc3000_configspi(FAR struct spi_dev_s *spi)
 {
-  idbg("Mode: %d Bits: 8 Frequency: %d\n",
+  ndbg("Mode: %d Bits: 8 Frequency: %d\n",
        CONFIG_CC3000_SPIMODE, CONFIG_CC3000_SPI_FREQUENCY);
 
   SPI_SETMODE(spi, CONFIG_CC3000_SPIMODE);
@@ -498,7 +503,7 @@ static void * select_thread_func(FAR void *arg)
 
   memset(&timeout, 0, sizeof(struct timeval));
   timeout.tv_sec  = 0;
-  timeout.tv_usec = (100);  /* .1 msecs */
+  timeout.tv_usec = (500000);  /* 500 msecs */
 
   while (1)
     {
@@ -518,6 +523,27 @@ static void * select_thread_func(FAR void *arg)
         {
           if (priv->sockets[s].sd != FREE_SLOT)
             {
+              if (priv->sockets[s].sd == CLOSE_SLOT)
+                {
+                  priv->sockets[s].sd = FREE_SLOT;
+                  waitlldbg("Close\n");
+                  int count;
+                  do
+                    {
+                      sem_getvalue(&priv->sockets[s].semwait, &count);
+                      if (count < 0)
+                        {
+                          /* Release the waiting threads */
+
+                          waitlldbg("Closed Signaled %d\n",count);
+                          sem_post(&priv->sockets[s].semwait);
+                        }
+                    }
+                  while (count < 0);
+
+                  continue;
+                }
+
               CC3000_FD_SET(priv->sockets[s].sd, &readsds);
               if (maxFD <= priv->sockets[s].sd)
                 {
@@ -542,10 +568,12 @@ static void * select_thread_func(FAR void *arg)
         {
           for (s = 0; s < CONFIG_WL_MAX_SOCKETS; s++)
             {
-              if (priv->sockets[s].sd != FREE_SLOT &&                        /* Check that the socket is valid */
-                  priv->sockets[s].sd  != priv->accepting_socket.acc.sd  &&  /* Verify this is not an accept socket */
-                  CC3000_FD_ISSET(priv->sockets[s].sd, &readsds))            /* and has pending data */
+              if ((priv->sockets[s].sd != FREE_SLOT ||
+                   priv->sockets[s].sd != CLOSE_SLOT) &&                      /* Check that the socket is valid */
+                   priv->sockets[s].sd  != priv->accepting_socket.acc.sd  &&  /* Verify this is not an accept socket */
+                   CC3000_FD_ISSET(priv->sockets[s].sd, &readsds))            /* and has pending data */
                 {
+                  waitlldbg("Signaled %d\n",priv->sockets[s].sd);
                   sem_post(&priv->sockets[s].semwait);                       /* release the waiting thread */
                 }
             }
@@ -553,9 +581,16 @@ static void * select_thread_func(FAR void *arg)
 
       if (priv->accepting_socket.acc.sd != FREE_SLOT)                        /* If accept polling in needed */
         {
-          ret = cc3000_do_accept(priv->accepting_socket.acc.sd,              /* Send the select command on non blocking */
-                                &priv->accepting_socket.addr,                /* Set up in ioctl */
-                                &priv->accepting_socket.addrlen);
+          if (priv->accepting_socket.acc.sd == CLOSE_SLOT)
+            {
+              ret = CC3000_SOC_ERROR;
+            }
+            else
+            {
+              ret = cc3000_do_accept(priv->accepting_socket.acc.sd,              /* Send the select command on non blocking */
+                                     &priv->accepting_socket.addr,               /* Set up in ioctl */
+                                     &priv->accepting_socket.addrlen);
+            }
 
           if (ret != CC3000_SOC_IN_PROGRESS)                                 /* Not waiting => error or accepted */
             {
@@ -607,12 +642,14 @@ static void * cc3000_worker(FAR void *arg)
             {
             case eSPI_STATE_POWERUP:
               /* Signal the device has interrupted after power up */
+
               priv->state = eSPI_STATE_INITIALIZED;
               sem_post(&priv->readysem);
               break;
 
             case eSPI_STATE_WRITE_WAIT_IRQ:
               /* Signal the device has interrupted after Chip Select During a write operation */
+
               priv->state = eSPI_STATE_WRITE_PROCEED;
               sem_post(&priv->readysem);
               break;
@@ -627,11 +664,11 @@ static void * cc3000_worker(FAR void *arg)
 
                 cc3000_lock_and_select(priv->spi); /* Assert CS */
                 priv->state = eSPI_STATE_READ_PROCEED;
-                SPI_EXCHANGE(priv->spi,spi_readCommand,priv->rx_buffer, ARRAY_SIZE(spi_readCommand));
+                SPI_EXCHANGE(priv->spi,spi_readCommand,priv->rx_buffer.pbuffer, ARRAY_SIZE(spi_readCommand));
 
                /* Extract Length bytes from Rx Buffer */
 
-               uint16_t *pnetlen = (uint16_t *) &priv->rx_buffer[READ_OFFSET_TO_LENGTH];
+               uint16_t *pnetlen = (uint16_t *) &priv->rx_buffer.pbuffer[READ_OFFSET_TO_LENGTH];
                data_to_recv = ntohs(*pnetlen);
 
                if (data_to_recv)
@@ -649,8 +686,11 @@ static void * cc3000_worker(FAR void *arg)
                      * Will it fit?
                      */
 
-                    DEBUGASSERT(data_to_recv < ARRAY_SIZE(priv->rx_buffer));
-                    SPI_RECVBLOCK(priv->spi, priv->rx_buffer, data_to_recv);
+                    if (data_to_recv >= priv->rx_buffer_max_len){
+                        lowsyslog("data_to_recv %d",data_to_recv);
+                    }
+                    DEBUGASSERT(data_to_recv < priv->rx_buffer_max_len);
+                    SPI_RECVBLOCK(priv->spi, priv->rx_buffer.pbuffer, data_to_recv);
                   }
 
                 cc3000_deselect_and_unlock(priv->spi); /* De assert CS */
@@ -662,9 +702,9 @@ static void * cc3000_worker(FAR void *arg)
                     int count;
 
                     priv->state = eSPI_STATE_READ_READY;
-                    priv->rx_buffer_len = data_to_recv;
+                    priv->rx_buffer.len = data_to_recv;
 
-                    ret = mq_send(priv->queue, priv->rx_buffer, data_to_recv, 1);
+                    ret = mq_send(priv->queue, &priv->rx_buffer, sizeof(priv->rx_buffer), 1);
                     DEBUGASSERT(ret>=0);
 
                     /* Notify any waiters that new CC3000 data is available */
@@ -793,7 +833,7 @@ static int cc3000_open(FAR struct file *filep)
       priv->config->power_enable(priv->config, false);
 
       attr.mq_maxmsg  = NUMBER_OF_MSGS;
-      attr.mq_msgsize = CC3000_RX_BUFFER_SIZE;
+      attr.mq_msgsize = sizeof(cc3000_buffer_desc);
       attr.mq_flags   = 0;
 
       /* Set the flags for the open of the queue.
@@ -848,6 +888,17 @@ static int cc3000_open(FAR struct file *filep)
           goto errout_with_sem;
         }
 
+      /* Do late allocation with hopes of realloc not fragmenting */
+
+      priv->rx_buffer.pbuffer =  kmalloc(priv->rx_buffer_max_len);
+      DEBUGASSERT(priv->rx_buffer.pbuffer);
+      if (!priv->rx_buffer.pbuffer)
+        {
+          priv->crefs--;
+          ret = -errno;
+          goto errout_with_sem;
+        }
+
       priv->state = eSPI_STATE_POWERUP;
       priv->config->irq_clear(priv->config);
 
@@ -927,6 +978,10 @@ static int cc3000_close(FAR struct file *filep)
 
       mq_close(priv->queue);
       priv->queue = 0;
+
+      kfree(priv->rx_buffer.pbuffer);
+      priv->rx_buffer.pbuffer = 0;
+
     }
 
   cc3000_devgive(priv);
@@ -953,17 +1008,6 @@ static ssize_t cc3000_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
   CHECK_GUARD(priv);
 
-  /* Verify that the caller has provided a buffer large enough to receive
-   * the maximum data.
-   */
-
-  if (len < CC3000_RX_BUFFER_SIZE)
-    {
-      idbg("Unsupported read size: %d\n", len);
-      nread = -ENOSYS;
-      goto errout_without_sem;
-    }
-
   /* Get exclusive access to the driver data structure */
 
   ret = cc3000_devtake(priv);
@@ -974,7 +1018,19 @@ static ssize_t cc3000_read(FAR struct file *filep, FAR char *buffer, size_t len)
       goto errout_without_sem;
     }
 
-  for (nread = priv->rx_buffer_len; nread == 0; nread = priv->rx_buffer_len)
+  /* Verify that the caller has provided a buffer large enough to receive
+   * the maximum data.
+   */
+
+  if (len < priv->rx_buffer_max_len)
+    {
+      ndbg("Unsupported read size: %d\n", len);
+      nread = -ENOSYS;
+      goto errout_with_sem;
+    }
+
+
+  for (nread = priv->rx_buffer.len; nread == 0; nread = priv->rx_buffer.len)
     {
       if (nread > 0)
         {
@@ -1055,10 +1111,11 @@ static ssize_t cc3000_read(FAR struct file *filep, FAR char *buffer, size_t len)
 
   if (nread > 0)
     {
-      memcpy(buffer,priv->rx_buffer,priv->rx_buffer_len);
-      priv->rx_buffer_len = 0;
+      memcpy(buffer,priv->rx_buffer.pbuffer,priv->rx_buffer.len);
+      priv->rx_buffer.len = 0;
      }
 
+errout_with_sem:
   cc3000_devgive(priv);
 
 errout_without_sem:
@@ -1082,12 +1139,13 @@ errout_without_sem:
  *
  ****************************************************************************/
 
-static ssize_t cc3000_write(FAR struct file *filep, FAR const char *buffer, size_t len)
+static ssize_t cc3000_write(FAR struct file *filep, FAR const char *usrbuffer, size_t len)
 {
   FAR struct inode *inode;
   FAR struct cc3000_dev_s *priv;
-  int ret;
+  FAR char *buffer = (FAR char *) usrbuffer;
   ssize_t nwritten = 0;
+  int ret;
 
   /* Set the padding if count(buffer) is even ( as it will be come odd with header) */
 
@@ -1110,20 +1168,18 @@ static ssize_t cc3000_write(FAR struct file *filep, FAR const char *buffer, size
     {
       /* This should only happen if the wait was canceled by an signal */
 
-      idbg("sem_wait: %d\n", errno);
+      ndbg("sem_wait: %d\n", errno);
       nwritten = -errno;
       goto errout_without_sem;
     }
 
   /* Figure out the total length of the packet in order to figure out if there is padding or not */
 
-  priv->tx_buffer[0] = WRITE;
-  priv->tx_buffer[1] = HI(tx_len);
-  priv->tx_buffer[2] = LO(tx_len);
-  priv->tx_buffer[3] = 0;
-  priv->tx_buffer[4] = 0;
-  memcpy(&priv->tx_buffer[SPI_HEADER_SIZE],&buffer[SPI_HEADER_SIZE],tx_len);
-
+  buffer[0] = WRITE;
+  buffer[1] = HI(tx_len);
+  buffer[2] = LO(tx_len);
+  buffer[3] = 0;
+  buffer[4] = 0;
   tx_len += SPI_HEADER_SIZE;
 
   /* The first write transaction to occur after release of the shutdown has
@@ -1162,9 +1218,9 @@ static ssize_t cc3000_write(FAR struct file *filep, FAR const char *buffer, size
     {
       cc3000_lock_and_select(priv->spi); /* Assert CS */
       usdelay(55);
-      SPI_SNDBLOCK(priv->spi, priv->tx_buffer, 4);
+      SPI_SNDBLOCK(priv->spi, buffer, 4);
       usdelay(55);
-      SPI_SNDBLOCK(priv->spi, priv->tx_buffer+4, tx_len-4);
+      SPI_SNDBLOCK(priv->spi, buffer+4, tx_len-4);
     }
   else
     {
@@ -1185,7 +1241,7 @@ static ssize_t cc3000_write(FAR struct file *filep, FAR const char *buffer, size
           goto errout_without_sem;
         }
 
-      SPI_SNDBLOCK(priv->spi, priv->tx_buffer, tx_len);
+      SPI_SNDBLOCK(priv->spi, buffer, tx_len);
     }
 
   priv->state  = eSPI_STATE_WRITE_DONE;
@@ -1273,6 +1329,23 @@ static int cc3000_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
           break;
         }
 
+      case CC3000IOC_SETRX_SIZE:
+        {
+          irqstate_t flags;
+          FAR int *psize = (FAR int *)(arg);
+          int rv;
+
+          DEBUGASSERT(psize != NULL);
+          rv = priv->rx_buffer_max_len;
+          flags = irqsave();
+          priv->rx_buffer_max_len = *psize;
+          priv->rx_buffer.pbuffer = krealloc(priv->rx_buffer.pbuffer,*psize);
+          irqrestore(flags);
+          DEBUGASSERT(priv->rx_buffer.pbuffer);
+          *psize = rv;
+          break;
+        }
+
       default:
         ret = -ENOTTY;
         break;
@@ -1427,7 +1500,7 @@ int cc3000_register(FAR struct spi_dev_s *spi,
   priv = (FAR struct cc3000_dev_s *)kmalloc(sizeof(struct cc3000_dev_s));
   if (!priv)
     {
-      idbg("kmalloc(%d) failed\n", sizeof(struct cc3000_dev_s));
+      ndbg("kmalloc(%d) failed\n", sizeof(struct cc3000_dev_s));
       return -ENOMEM;
     }
 #endif
@@ -1440,6 +1513,8 @@ int cc3000_register(FAR struct spi_dev_s *spi,
   priv->spi    = spi;                /* Save the SPI device handle */
   priv->config = config;             /* Save the board configuration */
 
+  priv->rx_buffer_max_len = config->max_rx_size;
+
   sem_init(&priv->devsem,  0, 1);    /* Initialize device structure semaphore */
   sem_init(&priv->waitsem, 0, 0);    /* Initialize  event wait semaphore */
   sem_init(&priv->irqsem, 0, 0);     /* Initialize  IRQ Ready semaphore */
@@ -1469,7 +1544,7 @@ int cc3000_register(FAR struct spi_dev_s *spi,
   ret = config->irq_attach(config, cc3000_interrupt);
   if (ret < 0)
     {
-      idbg("Failed to attach interrupt\n");
+      ndbg("Failed to attach interrupt\n");
       goto errout_with_priv;
     }
 
@@ -1481,7 +1556,7 @@ int cc3000_register(FAR struct spi_dev_s *spi,
   ret = register_driver(drvname, &cc3000_fops, 0666, priv);
   if (ret < 0)
     {
-      idbg("register_driver() failed: %d\n", ret);
+      ndbg("register_driver() failed: %d\n", ret);
       goto errout_with_priv;
     }
 
@@ -1555,7 +1630,7 @@ static int cc3000_wait_data(FAR struct cc3000_dev_s *priv, int sockfd)
           sem_wait(&priv->selectsem);           /* Sleep select thread */
           cc3000_devtake(priv);
           sched_unlock();
-          break;
+          return priv->sockets[s].sd == sockfd ? OK : -1;
         }
     }
 
@@ -1663,28 +1738,41 @@ static int cc3000_remove_socket(FAR struct cc3000_dev_s *priv, int sd)
 {
   irqstate_t flags;
   int s;
+  sem_t *ps = 0;
 
   if (sd < 0)
     {
       return sd;
     }
 
- flags = irqsave();
- if (priv->accepting_socket.acc.sd == sd)
-   {
-     priv->accepting_socket.acc.sd = FREE_SLOT;
-     priv->accepting_socket.addrlen = 0;
-   }
+  flags = irqsave();
+  if (priv->accepting_socket.acc.sd == sd)
+    {
+      priv->accepting_socket.acc.sd = CLOSE_SLOT;
+      ps = &priv->accepting_socket.acc.semwait;
+    }
 
   for (s = 0; s < CONFIG_WL_MAX_SOCKETS; s++)
     {
       if (priv->sockets[s].sd == sd)
         {
-          priv->sockets[s].sd = FREE_SLOT;
+          priv->sockets[s].sd = CLOSE_SLOT;
+          ps = &priv->sockets[s].semwait;
           break;
         }
     }
 
   irqrestore(flags);
+  if (ps)
+    {
+      sched_lock();
+      cc3000_devgive(priv);
+      sem_post(&priv->selectsem);                    /* Wake select thread if need be */
+      sem_wait(ps);
+      sem_wait(&priv->selectsem);                    /* Sleep the Thread */
+      cc3000_devtake(priv);
+      sched_unlock();
+    }
+
   return s >= CONFIG_WL_MAX_SOCKETS ? -1 : OK;
 }
diff --git a/nuttx/drivers/wireless/cc3000/cc3000.h b/nuttx/drivers/wireless/cc3000/cc3000.h
index e3377ede1..703dc435b 100644
--- a/nuttx/drivers/wireless/cc3000/cc3000.h
+++ b/nuttx/drivers/wireless/cc3000/cc3000.h
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers//wireless/cc3000.h
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2013-2014 Gregory Nutt. All rights reserved.
  *   Authors: Gregory Nutt <gnutt@nuttx.org>
  *            David Sidrane <david_s5@nscdg.com>
  *
@@ -97,7 +97,7 @@ extern pthread_mutex_t g_cc3000_mut;
 
 typedef struct cc3000_socket_ent
 {
-  int sd;
+  volatile int sd;
   long status;
   sem_t semwait;
 } cc3000_socket_ent;
@@ -142,11 +142,8 @@ struct cc3000_dev_s
   FAR struct spi_dev_s *spi;            /* Saved SPI driver instance */
   mqd_t queue;                          /* For unsolicited data delivery */
   eDeviceStates state;                  /* The device state */
-  uint8_t rx_buffer[CC3000_RX_BUFFER_SIZE];
-  ssize_t rx_buffer_len;
-
-  uint8_t tx_buffer[CC3000_TX_BUFFER_SIZE];
-  ssize_t tx_buffer_len;
+  cc3000_buffer_desc rx_buffer;
+  ssize_t rx_buffer_max_len;
 
   /* The following is a list if socket structures of threads waiting
    * long operations to finish;
diff --git a/nuttx/drivers/wireless/cc3000/cc3000drv.c b/nuttx/drivers/wireless/cc3000/cc3000drv.c
index fc10ede83..b98dc0261 100644
--- a/nuttx/drivers/wireless/cc3000/cc3000drv.c
+++ b/nuttx/drivers/wireless/cc3000/cc3000drv.c
@@ -87,7 +87,7 @@ static struct
   gcSpiHandleRx pfRxHandler;
   pthread_t unsoliced_thread;
   bool run;
-  uint8_t rx_buffer[CC3000_RX_BUFFER_SIZE];
+  cc3000_buffer_desc rx_buffer;
   mqd_t  queue;
   sem_t *done;
 } spiconf;
@@ -175,8 +175,8 @@ uint8_t *cc3000_wait(void)
 {
   DEBUGASSERT(spiconf.cc3000fd);
 
-  mq_receive(spiconf.queue, spiconf.rx_buffer, CC3000_RX_BUFFER_SIZE, 0);
-  return spiconf.rx_buffer;
+  mq_receive(spiconf.queue, &spiconf.rx_buffer, sizeof(spiconf.rx_buffer), 0);
+  return spiconf.rx_buffer.pbuffer;
 }
 
 /*****************************************************************************
@@ -211,13 +211,13 @@ static void *unsoliced_thread_func(void *parameter)
 
   while(spiconf.run)
     {
-      memset(spiconf.rx_buffer,0,sizeof(spiconf.rx_buffer));
-      nbytes = mq_receive(spiconf.queue, spiconf.rx_buffer,
-                          CC3000_RX_BUFFER_SIZE, 0);
+      memset(&spiconf.rx_buffer,0,sizeof(spiconf.rx_buffer));
+      nbytes = mq_receive(spiconf.queue, &spiconf.rx_buffer,
+                          sizeof(spiconf.rx_buffer), 0);
       if (nbytes > 0)
         {
           nlldbg("%d Processed\n",nbytes);
-          spiconf.pfRxHandler(spiconf.rx_buffer);
+          spiconf.pfRxHandler(spiconf.rx_buffer.pbuffer);
         }
     }
 
diff --git a/nuttx/drivers/wireless/cc3000/evnt_handler.c b/nuttx/drivers/wireless/cc3000/evnt_handler.c
index 264856880..14f926c46 100644
--- a/nuttx/drivers/wireless/cc3000/evnt_handler.c
+++ b/nuttx/drivers/wireless/cc3000/evnt_handler.c
@@ -519,6 +519,11 @@ uint8_t *hci_event_handler(void *pRetParams, uint8_t *from, uint8_t *fromlen)
               memcpy(pRetParams, pucReceivedParams + HCI_DATA_HEADER_SIZE + ucArgsize,
                      usLength - ucArgsize);
 
+              if (fromlen)
+                {
+                  *fromlen =  usLength - ucArgsize;
+                }
+
               tSLInformation.usRxDataPending = 0;
             }
 
diff --git a/nuttx/drivers/wireless/cc3000/nvmem.c b/nuttx/drivers/wireless/cc3000/nvmem.c
index c45f43946..95ac8916d 100644
--- a/nuttx/drivers/wireless/cc3000/nvmem.c
+++ b/nuttx/drivers/wireless/cc3000/nvmem.c
@@ -113,7 +113,7 @@ signed long nvmem_read(unsigned long ulFileId, unsigned long ulLength,
    * big enough to store also parameters of nvmem
    */
 
-  SimpleLinkWaitData(buff, 0, 0);
+  SimpleLinkWaitData(buff, 0, &ucStatus);
 
   cc3000_lib_unlock();
 
diff --git a/nuttx/drivers/wireless/cc3000/socket.c b/nuttx/drivers/wireless/cc3000/socket.c
index aa67d8606..122687a58 100644
--- a/nuttx/drivers/wireless/cc3000/socket.c
+++ b/nuttx/drivers/wireless/cc3000/socket.c
@@ -61,6 +61,8 @@
 #  define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 #endif
 
+#define waitlldbg(x,...) // lldbg
+
 /****************************************************************************
  * Private Types
  ****************************************************************************/
@@ -187,11 +189,14 @@ int cc3000_closesocket(int sockfd)
 {
   int ret;
 
-  cc3000_lib_lock();
-  ret = cc3000_closesocket_impl(sockfd);
 #ifdef CONFIG_CC3000_MT
+  waitlldbg("remove\n");
   cc3000_remove_socket(sockfd);
 #endif
+  cc3000_lib_lock();
+  waitlldbg("Call closesocketl\n");
+  ret = cc3000_closesocket_impl(sockfd);
+  waitlldbg("return closesocket\n");
   cc3000_lib_unlock();
   return ret;
 }
@@ -587,7 +592,9 @@ ssize_t cc3000_recv(int sockfd, FAR void *buf, size_t len, int flags)
   ssize_t ret;
 
 #ifdef CONFIG_CC3000_MT
+  waitlldbg("wait\n");
   ret = cc3000_wait_data(sockfd);
+  waitlldbg("wait %d\n", ret);
   if (ret != OK )
     {
       return -1;
@@ -595,7 +602,9 @@ ssize_t cc3000_recv(int sockfd, FAR void *buf, size_t len, int flags)
 #endif
 
   cc3000_lib_lock();
+  waitlldbg("recv\n");
   ret = cc3000_recv_impl(sockfd, buf, len, flags);
+  waitlldbg("recv %d\n", ret);
   cc3000_lib_unlock();
   return ret;
 }
diff --git a/nuttx/drivers/wireless/cc3000/socket_imp.c b/nuttx/drivers/wireless/cc3000/socket_imp.c
index 8ebc16d3f..7354f04fe 100644
--- a/nuttx/drivers/wireless/cc3000/socket_imp.c
+++ b/nuttx/drivers/wireless/cc3000/socket_imp.c
@@ -149,7 +149,10 @@ int HostFlowControlConsumeBuff(int sd)
        * the buffers
        */
 
-      usleep(100000);
+      if (0 == tSLInformation.usNumberOfFreeBuffers)
+        {
+          usleep(100000);
+        }
     }
   while (0 == tSLInformation.usNumberOfFreeBuffers);
 
diff --git a/nuttx/drivers/wireless/cc3000/wlan.c b/nuttx/drivers/wireless/cc3000/wlan.c
index 5e680a697..08356d322 100644
--- a/nuttx/drivers/wireless/cc3000/wlan.c
+++ b/nuttx/drivers/wireless/cc3000/wlan.c
@@ -60,6 +60,11 @@
 #define SMART_CONFIG_PROFILE_SIZE        67   /* 67 = 32 (max ssid) + 32 (max key) +
                                                * 1 (SSID length) + 1 (security type) +
                                                * 1 (key length) */
+
+/* SOCKET_SELECT_PARAMS_LEN + SPI_HEADER_SIZE++SIMPLE_LINK_HCI_DATA_HEADER_SIZ */
+
+#define MAX_HCI_CMD_LENGTH              (44+SIMPLE_LINK_HCI_DATA_HEADER_SIZE+SPI_HEADER_SIZE)
+
 /* Patches type */
 
 #define PATCHES_HOST_TYPE_WLAN_DRIVER    0x01
@@ -97,8 +102,6 @@
  * Private Variables
  ****************************************************************************/
 
-static uint8_t wlan_tx_buffer[CC3000_TX_BUFFER_SIZE];
-
 /*****************************************************************************
  * Public Data
  *****************************************************************************/
@@ -187,7 +190,9 @@ static void SimpleLink_Init_Start(uint16_t usPatchesAvailableAtHost)
  *
  *****************************************************************************/
 
-void wlan_init(tWlanCB sWlanCB, tFWPatches sFWPatches,
+void wlan_init(size_t max_tx_len,
+               tWlanCB sWlanCB,
+               tFWPatches sFWPatches,
                tDriverPatches sDriverPatches,
                tBootLoaderPatches sBootLoaderPatches)
 {
@@ -196,6 +201,13 @@ void wlan_init(tWlanCB sWlanCB, tFWPatches sFWPatches,
   tSLInformation.sDriverPatches = sDriverPatches;
   tSLInformation.sBootLoaderPatches = sBootLoaderPatches;
 
+  /* Allocate the memory for the RX/TX data transactions */
+
+  tSLInformation.pucTxCommandBuffer = malloc(max_tx_len);
+  tSLInformation.usrBuffer.pbuffer = &tSLInformation.pucTxCommandBuffer[MAX_HCI_CMD_LENGTH];
+  tSLInformation.usrBuffer.len = max_tx_len - MAX_HCI_CMD_LENGTH;
+
+
   /* Init I/O callback */
   /* Init asynchronous events callback */
 
@@ -276,10 +288,6 @@ void wlan_start(uint16_t usPatchesAvailableAtHost)
   tSLInformation.usEventOrDataReceived = 0;
   tSLInformation.pucReceivedData = 0;
 
-  /* Allocate the memory for the RX/TX data transactions */
-
-  tSLInformation.pucTxCommandBuffer = (uint8_t *)wlan_tx_buffer;
-
   /* Init spi */
 
   cc3000_open(SpiReceiveHandler);
@@ -294,6 +302,22 @@ void wlan_start(uint16_t usPatchesAvailableAtHost)
 }
 
 /*****************************************************************************
+ * Name: wlan_get_buffer
+ *
+ * Input Parameters:
+ *   pdes - Location to return the buffer pointer.
+ *
+ * Returned Value:
+ *   None
+ *
+ *****************************************************************************/
+
+void wlan_get_buffer(wlan_buffer_desc *pdes)
+{
+  *pdes = tSLInformation.usrBuffer;
+}
+
+/*****************************************************************************
  * Name: wlan_stop
  *
  * Input Parameters: