chore(i3c): use boolean for binary result functions

fpistm · fpistm · commit cbf2d569c06c · 2026-05-21T09:46:56.000+02:00
Signed-off-by: Frederic Pillon &lt;frederic.pillon@st.com&gt;
diff --git a/libraries/I3C/src/I3C.cpp b/libraries/I3C/src/I3C.cpp
@@ -676,13 +676,13 @@ bool I3CBus::isI3CDeviceReady(uint8_t dynAddr, uint32_t trials, uint32_t timeout
 // Low-level CCC helpers
 // ============================================================================
 
-int I3CBus::cccBroadcastWrite(uint8_t cccId,
+bool I3CBus::cccBroadcastWrite(uint8_t cccId,
                               const uint8_t *data,
                               uint16_t length,
                               bool withDefByte,
                               uint32_t timeout)
 {
-  int result = -1;
+  bool result = false;
 
   if (_initialized) {
     uint32_t        controlBuffer[0xFF];
@@ -712,11 +712,11 @@ int I3CBus::cccBroadcastWrite(uint8_t cccId,
     if (st == HAL_OK) {
       st = HAL_I3C_Ctrl_TransmitCCC(&_hi3c, &context, timeout);
       if (st == HAL_OK) {
-        result = 0;
+        result = true;
       } else {
         uint32_t err = HAL_I3C_GetError(&_hi3c);
         if ((err & HAL_I3C_ERROR_CE2) != 0U) {
-          result = 0;
+          result = true;
         }
       }
     }
@@ -725,14 +725,14 @@ int I3CBus::cccBroadcastWrite(uint8_t cccId,
   return result;
 }
 
-int I3CBus::cccDirectWrite(uint8_t targetAddr,
+bool I3CBus::cccDirectWrite(uint8_t targetAddr,
                            uint8_t cccId,
                            const uint8_t *data,
                            uint16_t length,
                            bool withDefByte,
                            uint32_t timeout)
 {
-  int result = -1;
+  bool result = false;
 
   if (_initialized) {
     uint32_t        controlBuffer[0xFF];
@@ -767,21 +767,21 @@ int I3CBus::cccDirectWrite(uint8_t targetAddr,
     if (st == HAL_OK) {
       st = HAL_I3C_Ctrl_TransmitCCC(&_hi3c, &context, timeout);
       if (st == HAL_OK) {
-        result = 0;
+        result = true;
       }
     }
   }
 
   return result;
 }
 
-int I3CBus::cccDirectRead(uint8_t targetAddr,
+bool I3CBus::cccDirectRead(uint8_t targetAddr,
                           uint8_t cccId,
                           uint8_t *rxData,
                           uint16_t rxLength,
                           uint32_t timeout)
 {
-  int result = -1;
+  bool result = false;
 
   if (_initialized && (rxData != nullptr) && (rxLength != 0U)) {
     uint32_t        controlBuffer[0xFF];
@@ -812,7 +812,7 @@ int I3CBus::cccDirectRead(uint8_t targetAddr,
     if (st == HAL_OK) {
       st = HAL_I3C_Ctrl_ReceiveCCC(&_hi3c, &context, timeout);
       if (st == HAL_OK) {
-        result = 0;
+        result = true;
       }
     }
   }
@@ -824,13 +824,13 @@ int I3CBus::cccDirectRead(uint8_t targetAddr,
 // CCC direct-read helpers
 // ============================================================================
 
-int I3CBus::getbcr(uint8_t dynAddr, uint8_t &bcr, uint32_t timeout)
+bool I3CBus::getbcr(uint8_t dynAddr, uint8_t &bcr, uint32_t timeout)
 {
-  int result = 0;
+  bool result = false;
   uint8_t rxData[1] = {0};
 
-  int rc = cccDirectRead(dynAddr, I3C_CCC_GETBCR_DIR, rxData, 1U, timeout);
-  if (rc != 0) {
+  bool rc = cccDirectRead(dynAddr, I3C_CCC_GETBCR_DIR, rxData, 1U, timeout);
+  if (rc) {
     result = rc;
   } else {
     bcr = rxData[0];
@@ -839,13 +839,13 @@ int I3CBus::getbcr(uint8_t dynAddr, uint8_t &bcr, uint32_t timeout)
   return result;
 }
 
-int I3CBus::getdcr(uint8_t dynAddr, uint8_t &dcr, uint32_t timeout)
+bool I3CBus::getdcr(uint8_t dynAddr, uint8_t &dcr, uint32_t timeout)
 {
-  int result = 0;
+  bool result = false;
   uint8_t rxData[1] = {0};
 
-  int rc = cccDirectRead(dynAddr, I3C_CCC_GETDCR_DIR, rxData, 1U, timeout);
-  if (rc != 0) {
+  bool rc = cccDirectRead(dynAddr, I3C_CCC_GETDCR_DIR, rxData, 1U, timeout);
+  if (rc) {
     result = rc;
   } else {
     dcr = rxData[0];
@@ -854,13 +854,13 @@ int I3CBus::getdcr(uint8_t dynAddr, uint8_t &dcr, uint32_t timeout)
   return result;
 }
 
-int I3CBus::getpid(uint8_t dynAddr, uint64_t &pid, uint32_t timeout)
+bool I3CBus::getpid(uint8_t dynAddr, uint64_t &pid, uint32_t timeout)
 {
-  int result = 0;
+  bool result = false;
   uint8_t rxData[6] = {0};
 
-  int rc = cccDirectRead(dynAddr, I3C_CCC_GETPID_DIR, rxData, 6U, timeout);
-  if (rc != 0) {
+  bool rc = cccDirectRead(dynAddr, I3C_CCC_GETPID_DIR, rxData, 6U, timeout);
+  if (rc) {
     result = rc;
   } else {
     pid = 0ULL;
@@ -879,24 +879,24 @@ int I3CBus::getpid(uint8_t dynAddr, uint64_t &pid, uint32_t timeout)
 // 9. High-level CCC commands
 // ============================================================================
 
-int I3CBus::resetDynamicAddresses()
+bool I3CBus::resetDynamicAddresses()
 {
   return cccBroadcastWrite(I3C_CCC_RSTDAA_BCAST, nullptr, 0U, false, 1000U);
 }
 
-int I3CBus::disableEvents(const uint8_t *pCCCData, uint16_t length)
+bool I3CBus::disableEvents(const uint8_t *pCCCData, uint16_t length)
 {
   return cccBroadcastWrite(I3C_CCC_DISEC_BCAST, pCCCData, length, length > 0U, 1000U);
 }
 
-int I3CBus::assignAllStaticAsDynamic()
+bool I3CBus::assignAllStaticAsDynamic()
 {
   return cccBroadcastWrite(I3C_CCC_SETAASA_BCAST, nullptr, 0U, false, 1000U);
 }
 
-int I3CBus::assignDynamicAddress(uint8_t staticAddr7, uint8_t dynAddr7)
+bool I3CBus::assignDynamicAddress(uint8_t staticAddr7, uint8_t dynAddr7)
 {
-  int result = -1;
+  bool result = false;
 
   if (_initialized) {
     uint8_t daByte = static_cast<uint8_t>((dynAddr7 & 0x7FU) << 1);
@@ -906,15 +906,15 @@ int I3CBus::assignDynamicAddress(uint8_t staticAddr7, uint8_t dynAddr7)
   return result;
 }
 
-int I3CBus::disecAll()
+bool I3CBus::disecAll()
 {
   const uint8_t evAll = I3C_CCC_EVT_ALL;
   return disableEvents(&evAll, 1U);
 }
 
-int I3CBus::rstactWholeTarget()
+bool I3CBus::rstactWholeTarget()
 {
-  int result = -1;
+  bool result = false;
 
   if (_initialized) {
     uint8_t defByte = I3C_CCC_RSTACT_RESET_WHOLE_TARGET;
@@ -928,9 +928,9 @@ int I3CBus::rstactWholeTarget()
   return result;
 }
 
-int I3CBus::rstactPeripheralOnly()
+bool I3CBus::rstactPeripheralOnly()
 {
-  int result = -1;
+  bool result = false;
 
   if (_initialized) {
     uint8_t defByte = I3C_CCC_RSTACT_PERIPHERAL_ONLY;
@@ -960,7 +960,7 @@ int I3CBus::setEvents(uint8_t dynAddr,
   return result;
 }
 
-int I3CBus::enecHotJoin()
+bool I3CBus::enecHotJoin()
 {
   uint8_t evHj = I3C_CCC_EVT_HJ;
   return cccBroadcastWrite(I3C_CCC_ENEC_BCAST, &evHj, 1U, true, 1000U);
@@ -1136,7 +1136,7 @@ int I3CBus::assignKnownDevices(const I3CKnownDevice *knownDevices,
         continue;
       }
 
-      if (assignDynamicAddress(kd.staticAddr, dyn) == 0) {
+      if (assignDynamicAddress(kd.staticAddr, dyn)) {
         markAddrUsed(dyn);
 
         if (count < maxDiscovered) {
diff --git a/libraries/I3C/src/I3C.h b/libraries/I3C/src/I3C.h
@@ -296,14 +296,14 @@ class I3CBus {
     // ------------------------------------------------------------------------
     // CCC broadcast & direct commands
     // ------------------------------------------------------------------------
-    int resetDynamicAddresses();
-    int disableEvents(const uint8_t *pCCCData, uint16_t length);
-    int assignAllStaticAsDynamic();
-    int assignDynamicAddress(uint8_t staticAddr, uint8_t dynAddr);
+    bool resetDynamicAddresses();
+    bool disableEvents(const uint8_t *pCCCData, uint16_t length);
+    bool assignAllStaticAsDynamic();
+    bool assignDynamicAddress(uint8_t staticAddr, uint8_t dynAddr);
 
-    int getbcr(uint8_t dynAddr, uint8_t &bcr, uint32_t timeout = 1000U);
-    int getdcr(uint8_t dynAddr, uint8_t &dcr, uint32_t timeout = 1000U);
-    int getpid(uint8_t dynAddr, uint64_t &pid, uint32_t timeout = 1000U);
+    bool getbcr(uint8_t dynAddr, uint8_t &bcr, uint32_t timeout = 1000U);
+    bool getdcr(uint8_t dynAddr, uint8_t &dcr, uint32_t timeout = 1000U);
+    bool getpid(uint8_t dynAddr, uint64_t &pid, uint32_t timeout = 1000U);
 
     // ------------------------------------------------------------------------
     // Discovery and dynamic address assignment
@@ -470,10 +470,10 @@ class I3CBus {
     // ------------------------------------------------------------------------
     // Bus sequencing helpers
     // ------------------------------------------------------------------------
-    int disecAll();
-    int enecHotJoin();
-    int rstactPeripheralOnly();
-    int rstactWholeTarget();
+    bool disecAll();
+    bool enecHotJoin();
+    bool rstactPeripheralOnly();
+    bool rstactWholeTarget();
 
     int assignKnownDevices(const I3CKnownDevice *knownDevices,
                            size_t numKnownDevices,
@@ -495,20 +495,20 @@ class I3CBus {
     // ------------------------------------------------------------------------
     // Low-level CCC helpers
     // ------------------------------------------------------------------------
-    int cccBroadcastWrite(uint8_t cccId,
+    bool cccBroadcastWrite(uint8_t cccId,
                           const uint8_t *data,
                           uint16_t length,
                           bool withDefByte,
                           uint32_t timeout = 1000U);
 
-    int cccDirectWrite(uint8_t targetAddr,
+    bool cccDirectWrite(uint8_t targetAddr,
                        uint8_t cccId,
                        const uint8_t *data,
                        uint16_t length,
                        bool withDefByte,
                        uint32_t timeout = 1000U);
 
-    int cccDirectRead(uint8_t targetAddr,
+    bool cccDirectRead(uint8_t targetAddr,
                       uint8_t cccId,
                       uint8_t *rxData,
                       uint16_t rxLength,

Original file line number	Diff line number	Diff line change
`@@ -676,13 +676,13 @@ bool I3CBus::isI3CDeviceReady(uint8_t dynAddr, uint32_t trials, uint32_t timeout`
`676`	`676`	`// Low-level CCC helpers`
`677`	`677`	`// ============================================================================`
`678`	`678`
`679`		`-int I3CBus::cccBroadcastWrite(uint8_t cccId,`
	`679`	`+bool I3CBus::cccBroadcastWrite(uint8_t cccId,`
`680`	`680`	`const uint8_t *data,`
`681`	`681`	`uint16_t length,`
`682`	`682`	`bool withDefByte,`
`683`	`683`	`uint32_t timeout)`
`684`	`684`	`{`
`685`		`- int result = -1;`
	`685`	`+ bool result = false;`
`686`	`686`
`687`	`687`	`if (_initialized) {`
`688`	`688`	`uint32_t controlBuffer[0xFF];`
`@@ -712,11 +712,11 @@ int I3CBus::cccBroadcastWrite(uint8_t cccId,`
`712`	`712`	`if (st == HAL_OK) {`
`713`	`713`	`st = HAL_I3C_Ctrl_TransmitCCC(&_hi3c, &context, timeout);`
`714`	`714`	`if (st == HAL_OK) {`
`715`		`- result = 0;`
	`715`	`+ result = true;`
`716`	`716`	`} else {`
`717`	`717`	`uint32_t err = HAL_I3C_GetError(&_hi3c);`
`718`	`718`	`if ((err & HAL_I3C_ERROR_CE2) != 0U) {`
`719`		`- result = 0;`
	`719`	`+ result = true;`
`720`	`720`	`}`
`721`	`721`	`}`
`722`	`722`	`}`
`@@ -725,14 +725,14 @@ int I3CBus::cccBroadcastWrite(uint8_t cccId,`
`725`	`725`	`return result;`
`726`	`726`	`}`
`727`	`727`
`728`		`-int I3CBus::cccDirectWrite(uint8_t targetAddr,`
	`728`	`+bool I3CBus::cccDirectWrite(uint8_t targetAddr,`
`729`	`729`	`uint8_t cccId,`
`730`	`730`	`const uint8_t *data,`
`731`	`731`	`uint16_t length,`
`732`	`732`	`bool withDefByte,`
`733`	`733`	`uint32_t timeout)`
`734`	`734`	`{`
`735`		`- int result = -1;`
	`735`	`+ bool result = false;`
`736`	`736`
`737`	`737`	`if (_initialized) {`
`738`	`738`	`uint32_t controlBuffer[0xFF];`
`@@ -767,21 +767,21 @@ int I3CBus::cccDirectWrite(uint8_t targetAddr,`
`767`	`767`	`if (st == HAL_OK) {`
`768`	`768`	`st = HAL_I3C_Ctrl_TransmitCCC(&_hi3c, &context, timeout);`
`769`	`769`	`if (st == HAL_OK) {`
`770`		`- result = 0;`
	`770`	`+ result = true;`
`771`	`771`	`}`
`772`	`772`	`}`
`773`	`773`	`}`
`774`	`774`
`775`	`775`	`return result;`
`776`	`776`	`}`
`777`	`777`
`778`		`-int I3CBus::cccDirectRead(uint8_t targetAddr,`
	`778`	`+bool I3CBus::cccDirectRead(uint8_t targetAddr,`
`779`	`779`	`uint8_t cccId,`
`780`	`780`	`uint8_t *rxData,`
`781`	`781`	`uint16_t rxLength,`
`782`	`782`	`uint32_t timeout)`
`783`	`783`	`{`
`784`		`- int result = -1;`
	`784`	`+ bool result = false;`
`785`	`785`
`786`	`786`	`if (_initialized && (rxData != nullptr) && (rxLength != 0U)) {`
`787`	`787`	`uint32_t controlBuffer[0xFF];`
`@@ -812,7 +812,7 @@ int I3CBus::cccDirectRead(uint8_t targetAddr,`
`812`	`812`	`if (st == HAL_OK) {`
`813`	`813`	`st = HAL_I3C_Ctrl_ReceiveCCC(&_hi3c, &context, timeout);`
`814`	`814`	`if (st == HAL_OK) {`
`815`		`- result = 0;`
	`815`	`+ result = true;`
`816`	`816`	`}`
`817`	`817`	`}`
`818`	`818`	`}`
`@@ -824,13 +824,13 @@ int I3CBus::cccDirectRead(uint8_t targetAddr,`
`824`	`824`	`// CCC direct-read helpers`
`825`	`825`	`// ============================================================================`
`826`	`826`
`827`		`-int I3CBus::getbcr(uint8_t dynAddr, uint8_t &bcr, uint32_t timeout)`
	`827`	`+bool I3CBus::getbcr(uint8_t dynAddr, uint8_t &bcr, uint32_t timeout)`
`828`	`828`	`{`
`829`		`- int result = 0;`
	`829`	`+ bool result = false;`
`830`	`830`	`uint8_t rxData[1] = {0};`
`831`	`831`
`832`		`- int rc = cccDirectRead(dynAddr, I3C_CCC_GETBCR_DIR, rxData, 1U, timeout);`
`833`		`- if (rc != 0) {`
	`832`	`+ bool rc = cccDirectRead(dynAddr, I3C_CCC_GETBCR_DIR, rxData, 1U, timeout);`
	`833`	`+ if (rc) {`
`834`	`834`	`result = rc;`
`835`	`835`	`} else {`
`836`	`836`	`bcr = rxData[0];`
`@@ -839,13 +839,13 @@ int I3CBus::getbcr(uint8_t dynAddr, uint8_t &bcr, uint32_t timeout)`
`839`	`839`	`return result;`
`840`	`840`	`}`
`841`	`841`
`842`		`-int I3CBus::getdcr(uint8_t dynAddr, uint8_t &dcr, uint32_t timeout)`
	`842`	`+bool I3CBus::getdcr(uint8_t dynAddr, uint8_t &dcr, uint32_t timeout)`
`843`	`843`	`{`
`844`		`- int result = 0;`
	`844`	`+ bool result = false;`
`845`	`845`	`uint8_t rxData[1] = {0};`
`846`	`846`
`847`		`- int rc = cccDirectRead(dynAddr, I3C_CCC_GETDCR_DIR, rxData, 1U, timeout);`
`848`		`- if (rc != 0) {`
	`847`	`+ bool rc = cccDirectRead(dynAddr, I3C_CCC_GETDCR_DIR, rxData, 1U, timeout);`
	`848`	`+ if (rc) {`
`849`	`849`	`result = rc;`
`850`	`850`	`} else {`
`851`	`851`	`dcr = rxData[0];`
`@@ -854,13 +854,13 @@ int I3CBus::getdcr(uint8_t dynAddr, uint8_t &dcr, uint32_t timeout)`
`854`	`854`	`return result;`
`855`	`855`	`}`
`856`	`856`
`857`		`-int I3CBus::getpid(uint8_t dynAddr, uint64_t &pid, uint32_t timeout)`
	`857`	`+bool I3CBus::getpid(uint8_t dynAddr, uint64_t &pid, uint32_t timeout)`
`858`	`858`	`{`
`859`		`- int result = 0;`
	`859`	`+ bool result = false;`
`860`	`860`	`uint8_t rxData[6] = {0};`
`861`	`861`
`862`		`- int rc = cccDirectRead(dynAddr, I3C_CCC_GETPID_DIR, rxData, 6U, timeout);`
`863`		`- if (rc != 0) {`
	`862`	`+ bool rc = cccDirectRead(dynAddr, I3C_CCC_GETPID_DIR, rxData, 6U, timeout);`
	`863`	`+ if (rc) {`
`864`	`864`	`result = rc;`
`865`	`865`	`} else {`
`866`	`866`	`pid = 0ULL;`
`@@ -879,24 +879,24 @@ int I3CBus::getpid(uint8_t dynAddr, uint64_t &pid, uint32_t timeout)`
`879`	`879`	`// 9. High-level CCC commands`
`880`	`880`	`// ============================================================================`
`881`	`881`
`882`		`-int I3CBus::resetDynamicAddresses()`
	`882`	`+bool I3CBus::resetDynamicAddresses()`
`883`	`883`	`{`
`884`	`884`	`return cccBroadcastWrite(I3C_CCC_RSTDAA_BCAST, nullptr, 0U, false, 1000U);`
`885`	`885`	`}`
`886`	`886`
`887`		`-int I3CBus::disableEvents(const uint8_t *pCCCData, uint16_t length)`
	`887`	`+bool I3CBus::disableEvents(const uint8_t *pCCCData, uint16_t length)`
`888`	`888`	`{`
`889`	`889`	`return cccBroadcastWrite(I3C_CCC_DISEC_BCAST, pCCCData, length, length > 0U, 1000U);`
`890`	`890`	`}`
`891`	`891`
`892`		`-int I3CBus::assignAllStaticAsDynamic()`
	`892`	`+bool I3CBus::assignAllStaticAsDynamic()`
`893`	`893`	`{`
`894`	`894`	`return cccBroadcastWrite(I3C_CCC_SETAASA_BCAST, nullptr, 0U, false, 1000U);`
`895`	`895`	`}`
`896`	`896`
`897`		`-int I3CBus::assignDynamicAddress(uint8_t staticAddr7, uint8_t dynAddr7)`
	`897`	`+bool I3CBus::assignDynamicAddress(uint8_t staticAddr7, uint8_t dynAddr7)`
`898`	`898`	`{`
`899`		`- int result = -1;`
	`899`	`+ bool result = false;`
`900`	`900`
`901`	`901`	`if (_initialized) {`
`902`	`902`	`uint8_t daByte = static_cast<uint8_t>((dynAddr7 & 0x7FU) << 1);`
`@@ -906,15 +906,15 @@ int I3CBus::assignDynamicAddress(uint8_t staticAddr7, uint8_t dynAddr7)`
`906`	`906`	`return result;`
`907`	`907`	`}`
`908`	`908`
`909`		`-int I3CBus::disecAll()`
	`909`	`+bool I3CBus::disecAll()`
`910`	`910`	`{`
`911`	`911`	`const uint8_t evAll = I3C_CCC_EVT_ALL;`
`912`	`912`	`return disableEvents(&evAll, 1U);`
`913`	`913`	`}`
`914`	`914`
`915`		`-int I3CBus::rstactWholeTarget()`
	`915`	`+bool I3CBus::rstactWholeTarget()`
`916`	`916`	`{`
`917`		`- int result = -1;`
	`917`	`+ bool result = false;`
`918`	`918`
`919`	`919`	`if (_initialized) {`
`920`	`920`	`uint8_t defByte = I3C_CCC_RSTACT_RESET_WHOLE_TARGET;`
`@@ -928,9 +928,9 @@ int I3CBus::rstactWholeTarget()`
`928`	`928`	`return result;`
`929`	`929`	`}`
`930`	`930`
`931`		`-int I3CBus::rstactPeripheralOnly()`
	`931`	`+bool I3CBus::rstactPeripheralOnly()`
`932`	`932`	`{`
`933`		`- int result = -1;`
	`933`	`+ bool result = false;`
`934`	`934`
`935`	`935`	`if (_initialized) {`
`936`	`936`	`uint8_t defByte = I3C_CCC_RSTACT_PERIPHERAL_ONLY;`
`@@ -960,7 +960,7 @@ int I3CBus::setEvents(uint8_t dynAddr,`
`960`	`960`	`return result;`
`961`	`961`	`}`
`962`	`962`
`963`		`-int I3CBus::enecHotJoin()`
	`963`	`+bool I3CBus::enecHotJoin()`
`964`	`964`	`{`
`965`	`965`	`uint8_t evHj = I3C_CCC_EVT_HJ;`
`966`	`966`	`return cccBroadcastWrite(I3C_CCC_ENEC_BCAST, &evHj, 1U, true, 1000U);`
`@@ -1136,7 +1136,7 @@ int I3CBus::assignKnownDevices(const I3CKnownDevice *knownDevices,`
`1136`	`1136`	`continue;`
`1137`	`1137`	`}`
`1138`	`1138`
`1139`		`- if (assignDynamicAddress(kd.staticAddr, dyn) == 0) {`
	`1139`	`+ if (assignDynamicAddress(kd.staticAddr, dyn)) {`
`1140`	`1140`	`markAddrUsed(dyn);`
`1141`	`1141`
`1142`	`1142`	`if (count < maxDiscovered) {`