Google Git
Sign in
pigweed/third_party/github/STMicroelectronics/stm32f7xx_hal_driver/3d2118fc7b79d55f886971dab7cbda77b95f0bcb^!/.
commit
3d2118fc7b79d55f886971dab7cbda77b95f0bcb
[log]
author
Tasnim <tasnim.ouni@st.com>
Tue Apr 25 02:07:07 2023 +0100
committer
Tasnim <tasnim.ouni@st.com>
Tue Apr 25 09:26:49 2023 +0100
tree
9efa4d4235bc821b0b18182fa133bda4afb2edcf
parent
9cbff6625e51ba8d824d9b2f998b4da9c194209d [diff]
[HAL][CRYP] Apply MCUAstyle fixes and update Crypt/Decrypt IT processes to avoid Computation Completed IRQ fires before the DINR pointer increment

diff --git a/Src/stm32f7xx_hal_cryp.c b/Src/stm32f7xx_hal_cryp.c
index d46fcb6..015ce61 100644
--- a/Src/stm32f7xx_hal_cryp.c
+++ b/Src/stm32f7xx_hal_cryp.c

@@ -2533,15 +2533,17 @@
     /* Enable CRYP */
     __HAL_CRYP_ENABLE(hcryp);
 
-    /* Write the input block in the IN FIFO */
-    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
+       and it is ready for the next operation. */
     hcryp->CrypInCount++;
-    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
+    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + (hcryp->CrypInCount - 1U));
     hcryp->CrypInCount++;
-    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
+    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + (hcryp->CrypInCount - 1U));
     hcryp->CrypInCount++;
-    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
+    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + (hcryp->CrypInCount - 1U));
     hcryp->CrypInCount++;
+    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + (hcryp->CrypInCount - 1U));
 
 #else /* CRYP */
 
@@ -2780,7 +2782,8 @@
             __HAL_UNLOCK(hcryp);
             return HAL_ERROR;
           }
-        } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+        }
+        while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
 
         /* Clear CCF Flag */
         __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
@@ -2822,7 +2825,8 @@
           __HAL_UNLOCK(hcryp);
           return HAL_ERROR;
         }
-      } while (HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY));
+      }
+      while (HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY));
 
       /* Turn back to ALGOMODE of the configuration */
       MODIFY_REG(hcryp->Instance->CR, CRYP_CR_ALGOMODE, hcryp->Init.Algorithm);
@@ -2867,15 +2871,17 @@
     /* Enable CRYP */
     __HAL_CRYP_ENABLE(hcryp);
 
-    /* Write the input block in the IN FIFO */
-    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
+       and it is ready for the next operation. */
     hcryp->CrypInCount++;
-    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
+    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + (hcryp->CrypInCount - 1U));
     hcryp->CrypInCount++;
-    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
+    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + (hcryp->CrypInCount - 1U));
     hcryp->CrypInCount++;
-    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
+    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + (hcryp->CrypInCount - 1U));
     hcryp->CrypInCount++;
+    hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + (hcryp->CrypInCount - 1U));
 
 #else /* CRYP */
 
@@ -2961,7 +2967,8 @@
             __HAL_UNLOCK(hcryp);
             return HAL_ERROR;
           }
-        } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+        }
+        while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
 
         /* Clear CCF Flag */
         __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
@@ -3005,7 +3012,8 @@
           __HAL_UNLOCK(hcryp);
           return HAL_ERROR;
         }
-      } while (HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY));
+      }
+      while (HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY));
 
       /* Turn back to ALGOMODE of the configuration */
       MODIFY_REG(hcryp->Instance->CR, CRYP_CR_ALGOMODE, hcryp->Init.Algorithm);
@@ -3937,7 +3945,8 @@
         __HAL_UNLOCK(hcryp);
         return HAL_ERROR;
       }
-    } while ((hcryp->Instance->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN);
+    }
+    while ((hcryp->Instance->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN);
 
 #else /* AES */
 
@@ -3974,7 +3983,8 @@
         __HAL_UNLOCK(hcryp);
         return HAL_ERROR;
       }
-    } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+    }
+    while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
 
     /* Clear CCF flag */
     __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
@@ -4212,7 +4222,8 @@
         __HAL_UNLOCK(hcryp);
         return HAL_ERROR;
       }
-    } while ((hcryp->Instance->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN);
+    }
+    while ((hcryp->Instance->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN);
 
 #else /* AES */
 
@@ -4249,7 +4260,8 @@
         __HAL_UNLOCK(hcryp);
         return HAL_ERROR;
       }
-    } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+    }
+    while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
 
     /* Clear CCF flag */
     __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
@@ -4849,7 +4861,8 @@
         __HAL_UNLOCK(hcryp);
         return HAL_ERROR;
       }
-    } while ((hcryp->Instance->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN);
+    }
+    while ((hcryp->Instance->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN);
 
     /* Select header phase */
     CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
@@ -5010,7 +5023,8 @@
         __HAL_UNLOCK(hcryp);
         return HAL_ERROR;
       }
-    } while ((hcryp->Instance->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN);
+    }
+    while ((hcryp->Instance->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN);
 
 #else /* AES */
 
@@ -5056,7 +5070,8 @@
         __HAL_UNLOCK(hcryp);
         return HAL_ERROR;
       }
-    } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+    }
+    while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
     /* Clear CCF flag */
     __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
 
@@ -5101,7 +5116,8 @@
               __HAL_UNLOCK(hcryp);
               return HAL_ERROR;
             }
-          } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+          }
+          while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
           /* Clear CCF flag */
           __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
         }
@@ -5138,7 +5154,8 @@
               __HAL_UNLOCK(hcryp);
               return HAL_ERROR;
             }
-          } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+          }
+          while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
           /* Clear CCF flag */
           __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
         }
@@ -5172,7 +5189,8 @@
             __HAL_UNLOCK(hcryp);
             return HAL_ERROR;
           }
-        } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+        }
+        while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
         /* Clear CCF flag */
         __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
       }
@@ -5241,7 +5259,8 @@
           __HAL_UNLOCK(hcryp);
           return HAL_ERROR;
         }
-      } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+      }
+      while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
       /* Clear CCF flag */
       __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
 
@@ -5539,16 +5558,16 @@
     hcryp->Instance->DINR  = *(uint32_t *)(hcryp->pCrypInBuffPtr + hcryp->CrypInCount);
     hcryp->CrypInCount++;
     if ((hcryp->CrypInCount == (hcryp->Size / 4U)) && ((hcryp->Size % 16U) == 0U))
-      {
-        /* Call Input transfer complete callback */
+    {
+      /* Call Input transfer complete callback */
 #if (USE_HAL_CRYP_REGISTER_CALLBACKS == 1)
-        /*Call registered Input complete callback*/
-        hcryp->InCpltCallback(hcryp);
+      /*Call registered Input complete callback*/
+      hcryp->InCpltCallback(hcryp);
 #else
-        /*Call legacy weak Input complete callback*/
-        HAL_CRYP_InCpltCallback(hcryp);
+      /*Call legacy weak Input complete callback*/
+      HAL_CRYP_InCpltCallback(hcryp);
 #endif /* USE_HAL_CRYP_REGISTER_CALLBACKS */
-      }
+    }
   }
   else /* Last block of payload < 128bit*/
   {
@@ -5916,7 +5935,7 @@
   {
     headersize_in_bytes = hcryp->Init.HeaderSize;
   }
-  
+
   if (headersize_in_bytes != 0U)
   {
 
@@ -5960,7 +5979,8 @@
             __HAL_UNLOCK(hcryp);
             return HAL_ERROR;
           }
-        } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM));
+        }
+        while (HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM));
       }
     }
     else
@@ -5995,7 +6015,8 @@
             __HAL_UNLOCK(hcryp);
             return HAL_ERROR;
           }
-        } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM));
+        }
+        while (HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM));
       }
       /*  Last block optionally pad the data with zeros*/
       for (loopcounter = 0U; (loopcounter < ((headersize_in_bytes / 4U) % 4U)); loopcounter++)
@@ -6045,7 +6066,8 @@
           __HAL_UNLOCK(hcryp);
           return HAL_ERROR;
         }
-      } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM));
+      }
+      while (HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM));
     }
     /* Wait until the complete message has been processed */
     count = CRYP_TIMEOUT_GCMCCMHEADERPHASE;
@@ -6065,7 +6087,8 @@
         __HAL_UNLOCK(hcryp);
         return HAL_ERROR;
       }
-    } while (HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY));
+    }
+    while (HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY));
 
 #else /* AES */
 
@@ -6113,7 +6136,8 @@
             __HAL_UNLOCK(hcryp);
             return HAL_ERROR;
           }
-        } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+        }
+        while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
 
         /* Clear CCF flag */
         __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
@@ -6152,13 +6176,14 @@
             __HAL_UNLOCK(hcryp);
             return HAL_ERROR;
           }
-        } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+        }
+        while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
 
         /* Clear CCF flag */
         __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
       }
       /*  Last block optionally pad the data with zeros*/
-      for (loopcounter = 0U; (loopcounter < ((headersize_in_bytes /4U) % 4U)); loopcounter++)
+      for (loopcounter = 0U; (loopcounter < ((headersize_in_bytes / 4U) % 4U)); loopcounter++)
       {
         hcryp->Instance->DINR = *(uint32_t *)(hcryp->Init.Header + hcryp->CrypHeaderCount);
         hcryp->CrypHeaderCount++ ;
@@ -6205,7 +6230,8 @@
           __HAL_UNLOCK(hcryp);
           return HAL_ERROR;
         }
-      } while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
+      }
+      while (HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF));
 
       /* Clear CCF flag */
       __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CCF_CLEAR);
@@ -6323,10 +6349,10 @@
       loopcounter++;
       hcryp->CrypHeaderCount++;
       /* Pad the data with zeros to have a complete block */
-    while (loopcounter < 4U)
-    {
-      hcryp->Instance->DIN = 0x0U;
-      loopcounter++;
+      while (loopcounter < 4U)
+      {
+        hcryp->Instance->DIN = 0x0U;
+        loopcounter++;
         hcryp->CrypHeaderCount++;
       }
     }
@@ -6457,10 +6483,10 @@
       loopcounter++;
       hcryp->CrypHeaderCount++;
       /* Pad the data with zeros to have a complete block */
-    while (loopcounter < 4U)
-    {
-      hcryp->Instance->DINR = 0x0U;
-      loopcounter++;
+      while (loopcounter < 4U)
+      {
+        hcryp->Instance->DINR = 0x0U;
+        loopcounter++;
         hcryp->CrypHeaderCount++;
       }
     }