WebSVN – DashDisplay – Diff – /branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_i2c.c

       (@) These interfaces allow to manage a sequential transfer with a repeated start condition
           when a direction change during transfer
     [..]
       (+) A specific option field manage the different steps of a sequential transfer
       (+) Option field values are defined through @ref I2C_XferOptions_definition and are listed below:
-      (++) I2C_FIRST_AND_LAST_FRAME: No sequential usage, functionnal is same as associated interfaces in no sequential mode
+      (++) I2C_FIRST_AND_LAST_FRAME: No sequential usage, functional is same as associated interfaces in no sequential mode
       (++) I2C_FIRST_FRAME: Sequential usage, this option allow to manage a sequence with start condition, address
                             and data to transfer without a final stop condition
       (++) I2C_FIRST_AND_NEXT_FRAME: Sequential usage (Master only), this option allow to manage a sequence with start condition, address
                             and data to transfer without a final stop condition, an then permit a call the same master sequential interface
                             several times (like @ref HAL_I2C_Master_Seq_Transmit_IT() then @ref HAL_I2C_Master_Seq_Transmit_IT()
                             interface several times (link with option I2C_FIRST_AND_NEXT_FRAME).
                             Usage can, transfer several bytes one by one using HAL_I2C_Master_Seq_Transmit_IT(option I2C_FIRST_AND_NEXT_FRAME then I2C_NEXT_FRAME)
                               or HAL_I2C_Master_Seq_Receive_IT(option I2C_FIRST_AND_NEXT_FRAME then I2C_NEXT_FRAME)
                               or HAL_I2C_Master_Seq_Transmit_DMA(option I2C_FIRST_AND_NEXT_FRAME then I2C_NEXT_FRAME)
                               or HAL_I2C_Master_Seq_Receive_DMA(option I2C_FIRST_AND_NEXT_FRAME then I2C_NEXT_FRAME).
-                            Then usage of this option I2C_LAST_FRAME_NO_STOP at the last Transmit or Receive sequence permit to call the oposite interface Receive or Transmit
+                            Then usage of this option I2C_LAST_FRAME_NO_STOP at the last Transmit or Receive sequence permit to call the opposite interface Receive or Transmit
                               without stopping the communication and so generate a restart condition.
       (++) I2C_OTHER_FRAME: Sequential usage (Master only), this option allow to manage a restart condition after each call of the same master sequential
                             interface.
                             Usage can, transfer several bytes one by one with a restart with slave address between each bytes using HAL_I2C_Master_Seq_Transmit_IT(option I2C_FIRST_FRAME then I2C_OTHER_FRAME)
                               or HAL_I2C_Master_Seq_Receive_IT(option I2C_FIRST_FRAME then I2C_OTHER_FRAME)
                               or HAL_I2C_Master_Seq_Transmit_DMA(option I2C_FIRST_FRAME then I2C_OTHER_FRAME)
                               or HAL_I2C_Master_Seq_Receive_DMA(option I2C_FIRST_FRAME then I2C_OTHER_FRAME).
                             Then usage of this option I2C_OTHER_AND_LAST_FRAME at the last frame to help automatic generation of STOP condition.
-      (+) Differents sequential I2C interfaces are listed below:
+      (+) Different sequential I2C interfaces are listed below:
       (++) Sequential transmit in master I2C mode an amount of data in non-blocking mode using @ref HAL_I2C_Master_Seq_Transmit_IT()
             or using @ref HAL_I2C_Master_Seq_Transmit_DMA()
       (+++) At transmission end of current frame transfer, @ref HAL_I2C_MasterTxCpltCallback() is executed and user can
            add his own code by customization of function pointer @ref HAL_I2C_MasterTxCpltCallback()
       (++) Sequential receive in master I2C mode an amount of data in non-blocking mode using @ref HAL_I2C_Master_Seq_Receive_IT()
     hi2c->XferCount   = Size;
     hi2c->XferSize    = hi2c->XferCount;
     hi2c->XferOptions = I2C_NO_OPTION_FRAME;
     hi2c->Devaddress  = DevAddress;
-    /* Generate Start */
-    SET_BIT(hi2c->Instance->CR1, I2C_CR1_START);
     /* Process Unlocked */
     __HAL_UNLOCK(hi2c);
     /* Note : The I2C interrupts must be enabled after unlocking current process
               to avoid the risk of I2C interrupt handle execution before current
               process unlock */
     /* Enable EVT, BUF and ERR interrupt */
     __HAL_I2C_ENABLE_IT(hi2c, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR);
+    /* Generate Start */
+    SET_BIT(hi2c->Instance->CR1, I2C_CR1_START);
     return HAL_OK;
+  }
   else
+  {
     return HAL_BUSY;
     hi2c->XferCount   = Size;
     hi2c->XferSize    = hi2c->XferCount;
     hi2c->XferOptions = I2C_NO_OPTION_FRAME;
     hi2c->Devaddress  = DevAddress;
-    /* Enable Acknowledge */
-    SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
-    /* Generate Start */
-    SET_BIT(hi2c->Instance->CR1, I2C_CR1_START);
     /* Process Unlocked */
     __HAL_UNLOCK(hi2c);
     /* Note : The I2C interrupts must be enabled after unlocking current process
     process unlock */
     /* Enable EVT, BUF and ERR interrupt */
     __HAL_I2C_ENABLE_IT(hi2c, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR);
+    /* Enable Acknowledge */
+    SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
+    /* Generate Start */
+    SET_BIT(hi2c->Instance->CR1, I2C_CR1_START);
     return HAL_OK;
+  }
   else
+  {
     return HAL_BUSY;
     hi2c->XferOptions = I2C_NO_OPTION_FRAME;
     hi2c->Devaddress  = DevAddress;
     if (hi2c->XferSize > 0U)
+    {
-      /* Set the I2C DMA transfer complete callback */
-      hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
+      if (hi2c->hdmatx != NULL)
+      {
-      /* Set the DMA error callback */
+        /* Set the I2C DMA transfer complete callback */
-      hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
+        hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
-      /* Set the unused DMA callbacks to NULL */
+        /* Set the DMA error callback */
-      hi2c->hdmatx->XferHalfCpltCallback = NULL;
-      hi2c->hdmatx->XferAbortCallback = NULL;
+        hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
-      /* Enable the DMA channel */
+        /* Set the unused DMA callbacks to NULL */
-      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+        hi2c->hdmatx->XferHalfCpltCallback = NULL;
+        hi2c->hdmatx->XferAbortCallback = NULL;
-      if (dmaxferstatus == HAL_OK)
+        /* Enable the DMA channel */
+        dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+      }
+      else
+      {
-        /* Enable Acknowledge */
+        /* Update I2C state */
+        hi2c->State     = HAL_I2C_STATE_READY;
-        SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
+        hi2c->Mode      = HAL_I2C_MODE_NONE;
-        /* Generate Start */
+        /* Update I2C error code */
-        SET_BIT(hi2c->Instance->CR1, I2C_CR1_START);
+        hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+        /* Process Unlocked */
+        __HAL_UNLOCK(hi2c);
+        return HAL_ERROR;
+      }
+      if (dmaxferstatus == HAL_OK)
+      {
         /* Process Unlocked */
         __HAL_UNLOCK(hi2c);
         /* Note : The I2C interrupts must be enabled after unlocking current process
         to avoid the risk of I2C interrupt handle execution before current
         /* Enable EVT and ERR interrupt */
         __HAL_I2C_ENABLE_IT(hi2c, I2C_IT_EVT | I2C_IT_ERR);
         /* Enable DMA Request */
         SET_BIT(hi2c->Instance->CR2, I2C_CR2_DMAEN);
+        /* Enable Acknowledge */
+        SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
+        /* Generate Start */
+        SET_BIT(hi2c->Instance->CR1, I2C_CR1_START);
+      }
       else
+      {
         /* Update I2C state */
         hi2c->State     = HAL_I2C_STATE_READY;
     hi2c->XferOptions = I2C_NO_OPTION_FRAME;
     hi2c->Devaddress  = DevAddress;
     if (hi2c->XferSize > 0U)
+    {
+      if (hi2c->hdmarx != NULL)
+      {
-      /* Set the I2C DMA transfer complete callback */
+        /* Set the I2C DMA transfer complete callback */
-      hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
+        hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
-      /* Set the DMA error callback */
+        /* Set the DMA error callback */
-      hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
+        hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
-      /* Set the unused DMA callbacks to NULL */
+        /* Set the unused DMA callbacks to NULL */
-      hi2c->hdmarx->XferHalfCpltCallback = NULL;
+        hi2c->hdmarx->XferHalfCpltCallback = NULL;
-      hi2c->hdmarx->XferAbortCallback = NULL;
+        hi2c->hdmarx->XferAbortCallback = NULL;
-      /* Enable the DMA channel */
+        /* Enable the DMA channel */
-      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+        dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+      }
+      else
+      {
+        /* Update I2C state */
+        hi2c->State     = HAL_I2C_STATE_READY;
+        hi2c->Mode      = HAL_I2C_MODE_NONE;
+        /* Update I2C error code */
+        hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+        /* Process Unlocked */
+        __HAL_UNLOCK(hi2c);
+        return HAL_ERROR;
+      }
       if (dmaxferstatus == HAL_OK)
+      {
         /* Enable Acknowledge */
         SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
         return HAL_ERROR;
+      }
+    }
     else
+    {
-      /* Enable Acknowledge */
-      SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
-      /* Generate Start */
-      SET_BIT(hi2c->Instance->CR1, I2C_CR1_START);
       /* Process Unlocked */
       __HAL_UNLOCK(hi2c);
       /* Note : The I2C interrupts must be enabled after unlocking current process
       to avoid the risk of I2C interrupt handle execution before current
       process unlock */
       /* Enable EVT, BUF and ERR interrupt */
       __HAL_I2C_ENABLE_IT(hi2c, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR);
+      /* Enable Acknowledge */
+      SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
+      /* Generate Start */
+      SET_BIT(hi2c->Instance->CR1, I2C_CR1_START);
+    }
     return HAL_OK;
+  }
   else
     hi2c->pBuffPtr    = pData;
     hi2c->XferCount   = Size;
     hi2c->XferSize    = hi2c->XferCount;
     hi2c->XferOptions = I2C_NO_OPTION_FRAME;
+    if (hi2c->hdmatx != NULL)
+    {
-    /* Set the I2C DMA transfer complete callback */
+      /* Set the I2C DMA transfer complete callback */
-    hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
+      hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
-    /* Set the DMA error callback */
+      /* Set the DMA error callback */
-    hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
+      hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
-    /* Set the unused DMA callbacks to NULL */
+      /* Set the unused DMA callbacks to NULL */
-    hi2c->hdmatx->XferHalfCpltCallback = NULL;
+      hi2c->hdmatx->XferHalfCpltCallback = NULL;
-    hi2c->hdmatx->XferAbortCallback = NULL;
+      hi2c->hdmatx->XferAbortCallback = NULL;
-    /* Enable the DMA channel */
+      /* Enable the DMA channel */
-    dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+    }
+    else
+    {
+      /* Update I2C state */
+      hi2c->State     = HAL_I2C_STATE_LISTEN;
+      hi2c->Mode      = HAL_I2C_MODE_NONE;
+      /* Update I2C error code */
+      hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+      /* Process Unlocked */
+      __HAL_UNLOCK(hi2c);
+      return HAL_ERROR;
+    }
     if (dmaxferstatus == HAL_OK)
+    {
       /* Enable Address Acknowledge */
       SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
     hi2c->pBuffPtr    = pData;
     hi2c->XferCount   = Size;
     hi2c->XferSize    = hi2c->XferCount;
     hi2c->XferOptions = I2C_NO_OPTION_FRAME;
+    if (hi2c->hdmarx != NULL)
+    {
-    /* Set the I2C DMA transfer complete callback */
+      /* Set the I2C DMA transfer complete callback */
-    hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
+      hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
+      /* Set the DMA error callback */
+      hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
-    /* Set the DMA error callback */
+      /* Set the unused DMA callbacks to NULL */
+      hi2c->hdmarx->XferHalfCpltCallback = NULL;
-    hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
+      hi2c->hdmarx->XferAbortCallback = NULL;
-    /* Set the unused DMA callbacks to NULL */
+      /* Enable the DMA channel */
+      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+    }
+    else
+    {
+      /* Update I2C state */
-    hi2c->hdmarx->XferHalfCpltCallback = NULL;
+      hi2c->State     = HAL_I2C_STATE_LISTEN;
-    hi2c->hdmarx->XferAbortCallback = NULL;
+      hi2c->Mode      = HAL_I2C_MODE_NONE;
+      /* Update I2C error code */
+      hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+      /* Process Unlocked */
+      __HAL_UNLOCK(hi2c);
-    /* Enable the DMA channel */
+      return HAL_ERROR;
-    dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+    }
     if (dmaxferstatus == HAL_OK)
+    {
       /* Enable Address Acknowledge */
       SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
     hi2c->XferSize    = hi2c->XferCount;
     hi2c->XferOptions = I2C_NO_OPTION_FRAME;
     if (hi2c->XferSize > 0U)
+    {
+      if (hi2c->hdmatx != NULL)
+      {
-      /* Set the I2C DMA transfer complete callback */
+        /* Set the I2C DMA transfer complete callback */
-      hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
+        hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
-      /* Set the DMA error callback */
+        /* Set the DMA error callback */
-      hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
+        hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
-      /* Set the unused DMA callbacks to NULL */
+        /* Set the unused DMA callbacks to NULL */
-      hi2c->hdmatx->XferHalfCpltCallback = NULL;
+        hi2c->hdmatx->XferHalfCpltCallback = NULL;
-      hi2c->hdmatx->XferAbortCallback = NULL;
+        hi2c->hdmatx->XferAbortCallback = NULL;
-      /* Enable the DMA channel */
+        /* Enable the DMA channel */
-      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+        dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+      }
+      else
+      {
+        /* Update I2C state */
+        hi2c->State     = HAL_I2C_STATE_READY;
+        hi2c->Mode      = HAL_I2C_MODE_NONE;
+        /* Update I2C error code */
+        hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+        /* Process Unlocked */
+        __HAL_UNLOCK(hi2c);
+        return HAL_ERROR;
+      }
       if (dmaxferstatus == HAL_OK)
+      {
         /* Send Slave Address and Memory Address */
         if (I2C_RequestMemoryWrite(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG, tickstart) != HAL_OK)
           dmaxferstatus = HAL_DMA_Abort_IT(hi2c->hdmatx);
           /* Prevent unused argument(s) compilation and MISRA warning */
           UNUSED(dmaxferstatus);
-          /* Clear directly Complete callback as no XferAbortCallback is used to finalize Abort treatment */
+          /* Set the unused I2C DMA transfer complete callback to NULL */
-          if (hi2c->hdmatx != NULL)
-          {
-            hi2c->hdmatx->XferCpltCallback = NULL;
+          hi2c->hdmatx->XferCpltCallback = NULL;
-          }
           /* Disable Acknowledge */
           CLEAR_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
           hi2c->XferSize = 0U;
     hi2c->XferSize    = hi2c->XferCount;
     hi2c->XferOptions = I2C_NO_OPTION_FRAME;
     if (hi2c->XferSize > 0U)
+    {
+      if (hi2c->hdmarx != NULL)
+      {
-      /* Set the I2C DMA transfer complete callback */
+        /* Set the I2C DMA transfer complete callback */
-      hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
+        hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
-      /* Set the DMA error callback */
+        /* Set the DMA error callback */
-      hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
+        hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
-      /* Set the unused DMA callbacks to NULL */
+        /* Set the unused DMA callbacks to NULL */
-      hi2c->hdmarx->XferHalfCpltCallback = NULL;
+        hi2c->hdmarx->XferHalfCpltCallback = NULL;
-      hi2c->hdmarx->XferAbortCallback = NULL;
+        hi2c->hdmarx->XferAbortCallback = NULL;
-      /* Enable the DMA channel */
+        /* Enable the DMA channel */
-      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+        dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+      }
+      else
+      {
+        /* Update I2C state */
+        hi2c->State     = HAL_I2C_STATE_READY;
+        hi2c->Mode      = HAL_I2C_MODE_NONE;
+        /* Update I2C error code */
+        hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+        /* Process Unlocked */
+        __HAL_UNLOCK(hi2c);
+        return HAL_ERROR;
+      }
       if (dmaxferstatus == HAL_OK)
+      {
         /* Send Slave Address and Memory Address */
         if (I2C_RequestMemoryRead(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG, tickstart) != HAL_OK)
           dmaxferstatus = HAL_DMA_Abort_IT(hi2c->hdmarx);
           /* Prevent unused argument(s) compilation and MISRA warning */
           UNUSED(dmaxferstatus);
-          /* Clear directly Complete callback as no XferAbortCallback is used to finalize Abort treatment */
+          /* Set the unused I2C DMA transfer complete callback to NULL */
-          if (hi2c->hdmarx != NULL)
-          {
-            hi2c->hdmarx->XferCpltCallback = NULL;
+          hi2c->hdmarx->XferCpltCallback = NULL;
-          }
           /* Disable Acknowledge */
           CLEAR_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
           hi2c->XferSize = 0U;
     Prev_State = hi2c->PreviousState;
     if (hi2c->XferSize > 0U)
+    {
+      if (hi2c->hdmatx != NULL)
+      {
-      /* Set the I2C DMA transfer complete callback */
+        /* Set the I2C DMA transfer complete callback */
-      hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
+        hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
-      /* Set the DMA error callback */
+        /* Set the DMA error callback */
-      hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
+        hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
-      /* Set the unused DMA callbacks to NULL */
+        /* Set the unused DMA callbacks to NULL */
-      hi2c->hdmatx->XferHalfCpltCallback = NULL;
+        hi2c->hdmatx->XferHalfCpltCallback = NULL;
-      hi2c->hdmatx->XferAbortCallback = NULL;
+        hi2c->hdmatx->XferAbortCallback = NULL;
-      /* Enable the DMA channel */
+        /* Enable the DMA channel */
-      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+        dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+      }
+      else
+      {
+        /* Update I2C state */
+        hi2c->State     = HAL_I2C_STATE_READY;
+        hi2c->Mode      = HAL_I2C_MODE_NONE;
+        /* Update I2C error code */
+        hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+        /* Process Unlocked */
+        __HAL_UNLOCK(hi2c);
+        return HAL_ERROR;
+      }
       if (dmaxferstatus == HAL_OK)
+      {
         /* Enable Acknowledge */
         SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
+        {
           /* Enable Last DMA bit */
           SET_BIT(hi2c->Instance->CR2, I2C_CR2_LAST);
+        }
+      }
+      if (hi2c->hdmarx != NULL)
+      {
+        /* Set the I2C DMA transfer complete callback */
+        hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
-      /* Set the I2C DMA transfer complete callback */
+        /* Set the DMA error callback */
-      hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
+        hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
-      /* Set the DMA error callback */
+        /* Set the unused DMA callbacks to NULL */
+        hi2c->hdmarx->XferHalfCpltCallback = NULL;
-      hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
+        hi2c->hdmarx->XferAbortCallback = NULL;
-      /* Set the unused DMA callbacks to NULL */
+        /* Enable the DMA channel */
+        dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+      }
+      else
+      {
+        /* Update I2C state */
-      hi2c->hdmarx->XferHalfCpltCallback = NULL;
+        hi2c->State     = HAL_I2C_STATE_READY;
-      hi2c->hdmarx->XferAbortCallback = NULL;
+        hi2c->Mode      = HAL_I2C_MODE_NONE;
-      /* Enable the DMA channel */
+        /* Update I2C error code */
-      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+        hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+        /* Process Unlocked */
+        __HAL_UNLOCK(hi2c);
+        return HAL_ERROR;
+      }
       if (dmaxferstatus == HAL_OK)
+      {
         /* If transfer direction not change and there is no request to start another frame, do not generate Restart Condition */
         /* Mean Previous state is same as current state */
         if ((Prev_State != I2C_STATE_MASTER_BUSY_RX) || (IS_I2C_TRANSFER_OTHER_OPTIONS_REQUEST(XferOptions) == 1))
     hi2c->pBuffPtr    = pData;
     hi2c->XferCount   = Size;
     hi2c->XferSize    = hi2c->XferCount;
     hi2c->XferOptions = XferOptions;
+    if (hi2c->hdmatx != NULL)
+    {
-    /* Set the I2C DMA transfer complete callback */
+      /* Set the I2C DMA transfer complete callback */
-    hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
+      hi2c->hdmatx->XferCpltCallback = I2C_DMAXferCplt;
-    /* Set the DMA error callback */
+      /* Set the DMA error callback */
-    hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
+      hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
-    /* Set the unused DMA callbacks to NULL */
+      /* Set the unused DMA callbacks to NULL */
-    hi2c->hdmatx->XferHalfCpltCallback = NULL;
+      hi2c->hdmatx->XferHalfCpltCallback = NULL;
-    hi2c->hdmatx->XferAbortCallback = NULL;
+      hi2c->hdmatx->XferAbortCallback = NULL;
+      /* Enable the DMA channel */
+      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+    }
+    else
+    {
+      /* Update I2C state */
+      hi2c->State     = HAL_I2C_STATE_LISTEN;
+      hi2c->Mode      = HAL_I2C_MODE_NONE;
-    /* Enable the DMA channel */
+      /* Update I2C error code */
-    dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->DR, hi2c->XferSize);
+      hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+      /* Process Unlocked */
+      __HAL_UNLOCK(hi2c);
+      return HAL_ERROR;
+    }
     if (dmaxferstatus == HAL_OK)
+    {
       /* Enable Address Acknowledge */
       SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
     hi2c->pBuffPtr    = pData;
     hi2c->XferCount   = Size;
     hi2c->XferSize    = hi2c->XferCount;
     hi2c->XferOptions = XferOptions;
+    if (hi2c->hdmarx != NULL)
+    {
-    /* Set the I2C DMA transfer complete callback */
+      /* Set the I2C DMA transfer complete callback */
-    hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
+      hi2c->hdmarx->XferCpltCallback = I2C_DMAXferCplt;
-    /* Set the DMA error callback */
+      /* Set the DMA error callback */
-    hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
+      hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
-    /* Set the unused DMA callbacks to NULL */
+      /* Set the unused DMA callbacks to NULL */
-    hi2c->hdmarx->XferHalfCpltCallback = NULL;
+      hi2c->hdmarx->XferHalfCpltCallback = NULL;
-    hi2c->hdmarx->XferAbortCallback = NULL;
+      hi2c->hdmarx->XferAbortCallback = NULL;
-    /* Enable the DMA channel */
+      /* Enable the DMA channel */
-    dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+      dmaxferstatus = HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->DR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);
+    }
+    else
+    {
+      /* Update I2C state */
+      hi2c->State     = HAL_I2C_STATE_LISTEN;
+      hi2c->Mode      = HAL_I2C_MODE_NONE;
+      /* Update I2C error code */
+      hi2c->ErrorCode |= HAL_I2C_ERROR_DMA_PARAM;
+      /* Process Unlocked */
+      __HAL_UNLOCK(hi2c);
+      return HAL_ERROR;
+    }
     if (dmaxferstatus == HAL_OK)
+    {
       /* Enable Address Acknowledge */
       SET_BIT(hi2c->Instance->CR1, I2C_CR1_ACK);
           I2C_MasterTransmit_TXE(hi2c);
+        }
         /* BTF set -------------------------------------------------------------*/
         else if ((I2C_CHECK_FLAG(sr1itflags, I2C_FLAG_BTF) != RESET) && (I2C_CHECK_IT_SOURCE(itsources, I2C_IT_EVT) != RESET))
+        {
-          if (CurrentMode == HAL_I2C_MODE_MASTER)
+          if (CurrentState == HAL_I2C_STATE_BUSY_TX)
+          {
             I2C_MasterTransmit_BTF(hi2c);
+          }
           else /* HAL_I2C_MODE_MEM */
+          {
+            if (CurrentMode == HAL_I2C_MODE_MEM)
+            {
-            I2C_MemoryTransmit_TXE_BTF(hi2c);
+              I2C_MemoryTransmit_TXE_BTF(hi2c);
+            }
+          }
+        }
         else
+        {
           /* Do nothing */
         /* Generate Stop */
         SET_BIT(hi2c->Instance->CR1, I2C_CR1_STOP);
         hi2c->PreviousState = I2C_STATE_NONE;
         hi2c->State = HAL_I2C_STATE_READY;
+        if (hi2c->Mode == HAL_I2C_MODE_MEM)
+        {
-        hi2c->Mode = HAL_I2C_MODE_NONE;
+          hi2c->Mode = HAL_I2C_MODE_NONE;
+#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)
+          hi2c->MemTxCpltCallback(hi2c);
+#else
+          HAL_I2C_MemTxCpltCallback(hi2c);
+#endif /* USE_HAL_I2C_REGISTER_CALLBACKS */
+        }
+        else
+        {
+          hi2c->Mode = HAL_I2C_MODE_NONE;
 #if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)
-        hi2c->MasterTxCpltCallback(hi2c);
+          hi2c->MasterTxCpltCallback(hi2c);
 #else
-        HAL_I2C_MasterTxCpltCallback(hi2c);
+          HAL_I2C_MasterTxCpltCallback(hi2c);
 #endif /* USE_HAL_I2C_REGISTER_CALLBACKS */
+        }
+      }
+    }
+  }
   else
+  {
+  {
     if (CurrentState == HAL_I2C_STATE_BUSY_RX)
+    {
       /* Generate Restart */
       hi2c->Instance->CR1 |= I2C_CR1_START;
+      hi2c->EventCount++;
+    }
     else if ((hi2c->XferCount > 0U) && (CurrentState == HAL_I2C_STATE_BUSY_TX))
+    {
       /* Write data to DR */
       hi2c->Instance->DR = *hi2c->pBuffPtr;
 static void I2C_Master_ADD10(I2C_HandleTypeDef *hi2c)
+{
   /* Send slave address */
   hi2c->Instance->DR = I2C_10BIT_ADDRESS(hi2c->Devaddress);
-  if ((hi2c->hdmatx != NULL) || (hi2c->hdmarx != NULL))
+  if (((hi2c->hdmatx != NULL) && (hi2c->hdmatx->XferCpltCallback != NULL))
+      || ((hi2c->hdmarx != NULL) && (hi2c->hdmarx->XferCpltCallback != NULL)))
+  {
-    if ((hi2c->hdmatx->XferCpltCallback != NULL) || (hi2c->hdmarx->XferCpltCallback != NULL))
-    {
-      /* Enable DMA Request */
+    /* Enable DMA Request */
-      SET_BIT(hi2c->Instance->CR2, I2C_CR2_DMAEN);
+    SET_BIT(hi2c->Instance->CR2, I2C_CR2_DMAEN);
-    }
+  }
+}
 /**
   * @brief  Handle ADDR flag for Master
 #endif /* USE_HAL_I2C_REGISTER_CALLBACKS */
+  }
   else
+  {
     /* Clear ADDR flag */
-    __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_ADDR);
+    __HAL_I2C_CLEAR_ADDRFLAG(hi2c);
     /* Process Unlocked */
     __HAL_UNLOCK(hi2c);
+  }
+}
+  }
   return HAL_OK;
+}
 /**
-  * @brief  Convert I2Cx OTHER_xxx XferOptions to functionnal XferOptions.
+  * @brief  Convert I2Cx OTHER_xxx XferOptions to functional XferOptions.
   * @param  hi2c I2C handle.
   * @retval None
   */
 static void I2C_ConvertOtherXferOptions(I2C_HandleTypeDef *hi2c)
+{

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_i2c.c – Rev 56 → 61