px4_autopilot/nuttx-patches/00028-BACKPORT-mtd-FLASH-corruption.patch

diff --git NuttX/nuttx/drivers/mtd/at25.c NuttX/nuttx/drivers/mtd/at25.c
index 777ff38..c775e52 100644
--- NuttX/nuttx/drivers/mtd/at25.c
+++ NuttX/nuttx/drivers/mtd/at25.c
@@ -524,6 +524,12 @@ static ssize_t at25_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
 
   finfo("offset: %08lx nbytes: %d\n", (long)offset, (int)nbytes);
 
+  /* Lock the SPI bus NOW because the following call must be executed with
+   * the bus locked.
+   */
+
+  at25_lock(priv->dev);
+
   /* Wait for any preceding write to complete.  We could simplify things by
    * perform this wait at the end of each write operation (rather than at
    * the beginning of ALL operations), but have the wait first will slightly
@@ -532,9 +538,8 @@ static ssize_t at25_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
 
   at25_waitwritecomplete(priv);
 
-  /* Lock the SPI bus and select this FLASH part */
+  /* Select this FLASH part */
 
-  at25_lock(priv->dev);
   SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
 
   /* Send "Read from Memory " instruction */
diff --git NuttX/nuttx/drivers/mtd/is25xp.c NuttX/nuttx/drivers/mtd/is25xp.c
index 55b677b..4919344 100644
--- NuttX/nuttx/drivers/mtd/is25xp.c
+++ NuttX/nuttx/drivers/mtd/is25xp.c
@@ -748,6 +748,12 @@ static ssize_t is25xp_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbyte
 
   finfo("offset: %08lx nbytes: %d\n", (long)offset, (int)nbytes);
 
+  /* Lock the SPI bus NOW because the following call must be executed with
+   * the bus locked.
+   */
+
+  is25xp_lock(priv->dev);
+
   /* Wait for any preceding write to complete.  We could simplify things by
    * perform this wait at the end of each write operation (rather than at
    * the beginning of ALL operations), but have the wait first will slightly
@@ -759,9 +765,8 @@ static ssize_t is25xp_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbyte
       is25xp_waitwritecomplete(priv);
     }
 
-  /* Lock the SPI bus and select this FLASH part */
+  /* Select this FLASH part */
 
-  is25xp_lock(priv->dev);
   SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
 
   /* Send "Read from Memory " instruction */
@@ -782,6 +787,7 @@ static ssize_t is25xp_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbyte
 
   SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
   is25xp_unlock(priv->dev);
+
   finfo("return nbytes: %d\n", (int)nbytes);
   return nbytes;
 }
diff --git NuttX/nuttx/drivers/mtd/ramtron.c NuttX/nuttx/drivers/mtd/ramtron.c
index ad448c8..23e4ad1 100644
--- NuttX/nuttx/drivers/mtd/ramtron.c
+++ NuttX/nuttx/drivers/mtd/ramtron.c
@@ -532,14 +532,14 @@ static inline void ramtron_sendaddr(const struct ramtron_dev_s *priv, uint32_t a
  * Name:  ramtron_pagewrite
  ************************************************************************************/
 
-static inline int ramtron_pagewrite(struct ramtron_dev_s *priv, FAR const uint8_t *buffer,
-                                     off_t page)
+static inline int ramtron_pagewrite(struct ramtron_dev_s *priv,
+                                    FAR const uint8_t *buffer, off_t page)
 {
   off_t offset = page << priv->pageshift;
 
   finfo("page: %08lx offset: %08lx\n", (long)page, (long)offset);
 
-#ifndef RAMTRON_WRITEWAIT
+#ifndef CONFIG_RAMTRON_WRITEWAIT
   /* Wait for any preceding write to complete.  We could simplify things by
    * perform this wait at the end of each write operation (rather than at
    * the beginning of ALL operations), but have the wait first will slightly
@@ -574,7 +574,7 @@ static inline int ramtron_pagewrite(struct ramtron_dev_s *priv, FAR const uint8_
   SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
   finfo("Written\n");
 
-#ifdef RAMTRON_WRITEWAIT
+#ifdef CONFIG_RAMTRON_WRITEWAIT
   /* Wait for write completion now so we can report any errors to the caller. Thus
    * the caller will know whether or not if the data is on stable storage
    */
@@ -657,13 +657,19 @@ static ssize_t ramtron_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbyt
                             FAR uint8_t *buffer)
 {
   FAR struct ramtron_dev_s *priv = (FAR struct ramtron_dev_s *)dev;
-#ifdef RAMTRON_WRITEWAIT
+#ifdef CONFIG_RAMTRON_WRITEWAIT
   uint8_t status;
 #endif
 
   finfo("offset: %08lx nbytes: %d\n", (long)offset, (int)nbytes);
 
-#ifndef RAMTRON_WRITEWAIT
+  /* Lock the SPI bus NOW because the ramtron_waitwritecomplete call must be
+   * executed with the bus locked.
+   */
+
+  ramtron_lock(priv);
+
+#ifndef CONFIG_RAMTRON_WRITEWAIT
   /* Wait for any preceding write to complete.  We could simplify things by
    * perform this wait at the end of each write operation (rather than at
    * the beginning of ALL operations), but have the wait first will slightly
@@ -673,9 +679,8 @@ static ssize_t ramtron_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbyt
   (void)ramtron_waitwritecomplete(priv);
 #endif
 
-  /* Lock the SPI bus and select this FLASH part */
+  /* Select this FLASH part */
 
-  ramtron_lock(priv);
   SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
 
   /* Send "Read from Memory " instruction */
@@ -690,7 +695,7 @@ static ssize_t ramtron_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbyt
 
   SPI_RECVBLOCK(priv->dev, buffer, nbytes);
 
-#ifdef RAMTRON_WRITEWAIT
+#ifdef CONFIG_RAMTRON_WRITEWAIT
   /* Read the status register. This isn't strictly needed, but it gives us a
    * chance to detect if SPI transactions are operating correctly, which
    * allows us to catch complete device failures in the read path. We expect
diff --git NuttX/nuttx/drivers/mtd/sst25xx.c NuttX/nuttx/drivers/mtd/sst25xx.c
index 9f88348..22d71cc 100644
--- NuttX/nuttx/drivers/mtd/sst25xx.c
+++ NuttX/nuttx/drivers/mtd/sst25xx.c
@@ -679,7 +679,8 @@ static ssize_t sst25xx_bread(FAR struct mtd_dev_s *dev, off_t startblock, size_t
 
   /* On this device, we can handle the block read just like the byte-oriented read */
 
-  nbytes = sst25xx_read(dev, startblock << priv->pageshift, nblocks << priv->pageshift, buffer);
+  nbytes = sst25xx_read(dev, startblock << priv->pageshift,
+                        nblocks << priv->pageshift, buffer);
   if (nbytes > 0)
     {
         return nbytes >> priv->pageshift;
@@ -726,6 +727,12 @@ static ssize_t sst25xx_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbyt
 
   finfo("offset: %08lx nbytes: %d\n", (long)offset, (int)nbytes);
 
+  /* Lock the SPI bus NOW because the following conditional call to
+   * sst25xx_waitwritecomplete must be executed with the bus locked.
+   */
+
+  sst25xx_lock(priv->dev);
+
   /* Wait for any preceding write to complete.  We could simplify things by
    * perform this wait at the end of each write operation (rather than at
    * the beginning of ALL operations), but have the wait first will slightly
@@ -737,9 +744,8 @@ static ssize_t sst25xx_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbyt
       sst25xx_waitwritecomplete(priv);
     }
 
-  /* Lock the SPI bus and select this FLASH part */
+  /* Select this FLASH part */
 
-  sst25xx_lock(priv->dev);
   SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
 
   /* Send "Read from Memory " instruction */
diff --git NuttX/nuttx/drivers/mtd/w25.c NuttX/nuttx/drivers/mtd/w25.c
index 279525e..22e7ea5 100644
--- NuttX/nuttx/drivers/mtd/w25.c
+++ NuttX/nuttx/drivers/mtd/w25.c
@@ -1004,6 +1004,7 @@ static ssize_t w25_bread(FAR struct mtd_dev_s *dev, off_t startblock, size_t nbl
     {
       nbytes >>= W25_SECTOR512_SHIFT;
     }
+
 #else
   nbytes = w25_read(dev, startblock << W25_PAGE_SHIFT, nblocks << W25_PAGE_SHIFT, buffer);
   if (nbytes > 0)