libraries/Wire: Fix formatting.

Fix formatting.

Signed-off-by: iabdalkader <[email protected]>

Author: iabdalkader

libraries/Wire/Wire.cpp

@@ -78,151 +78,151 @@ void arduino::ZephyrI2C::setClock(uint32_t freq) {
     uint8_t speed;
 
     if (freq == 100000) {
-      speed = I2C_SPEED_STANDARD;
+        speed = I2C_SPEED_STANDARD;
     } else if (freq == 400000) {
-      speed = I2C_SPEED_FAST;
+        speed = I2C_SPEED_FAST;
     } else if (freq == 1000000) {
-      speed = I2C_SPEED_FAST_PLUS;
+        speed = I2C_SPEED_FAST_PLUS;
     } else {
-      speed = I2C_SPEED_STANDARD;
+        speed = I2C_SPEED_STANDARD;
     }
 
     i2c_configure(i2c_dev, I2C_SPEED_SET(speed) | I2C_MODE_CONTROLLER);
 }
 
 void arduino::ZephyrI2C::beginTransmission(uint8_t address) {
-  _address = address;
-  ring_buf_reset(&txRingBuffer.rb);
-  ring_buf_reset(&rxRingBuffer.rb);
+    _address = address;
+    ring_buf_reset(&txRingBuffer.rb);
+    ring_buf_reset(&rxRingBuffer.rb);
 }
 
 uint8_t arduino::ZephyrI2C::endTransmission(bool stopBit) {
-  int ret = 0;
-  uint8_t *buf = NULL;
-  size_t max = ring_buf_capacity_get(&txRingBuffer.rb);
-  size_t len = ring_buf_get_claim(&txRingBuffer.rb, &buf, max);
+    int ret = 0;
+    uint8_t *buf = NULL;
+    size_t max = ring_buf_capacity_get(&txRingBuffer.rb);
+    size_t len = ring_buf_get_claim(&txRingBuffer.rb, &buf, max);
 
-  if (len && buf) {
-    ret = i2c_write(i2c_dev, buf, len, _address);
-  }
+    if (len && buf) {
+        ret = i2c_write(i2c_dev, buf, len, _address);
+    }
 
-  // Must be called even if 0 bytes claimed.
-  ring_buf_get_finish(&txRingBuffer.rb, len);
+    // Must be called even if 0 bytes claimed.
+    ring_buf_get_finish(&txRingBuffer.rb, len);
 
-  return ret ? 1 : 0;
+    return ret ? 1 : 0;
 }
 
 uint8_t arduino::ZephyrI2C::endTransmission(void) {
-  return endTransmission(true);
+    return endTransmission(true);
 }
 
 size_t arduino::ZephyrI2C::requestFrom(uint8_t address, size_t len_in, bool stopBit) {
-  int ret = 0;
-  uint8_t *buf = NULL;
-  size_t len = ring_buf_put_claim(&rxRingBuffer.rb, &buf, len_in);
+    int ret = 0;
+    uint8_t *buf = NULL;
+    size_t len = ring_buf_put_claim(&rxRingBuffer.rb, &buf, len_in);
 
-  if (len && buf) {
-    ret = i2c_read(i2c_dev, buf, len, address);
-  }
+    if (len && buf) {
+        ret = i2c_read(i2c_dev, buf, len, address);
+    }
 
-  // Must be called even if 0 bytes claimed.
-  ring_buf_put_finish(&rxRingBuffer.rb, len);
+    // Must be called even if 0 bytes claimed.
+    ring_buf_put_finish(&rxRingBuffer.rb, len);
 
-  return ret ? 1 : 0;
+    return ret ? 1 : 0;
 }
 
 size_t arduino::ZephyrI2C::requestFrom(uint8_t address, size_t len) {
-  return requestFrom(address, len, true);
+    return requestFrom(address, len, true);
 }
 
 size_t arduino::ZephyrI2C::write(uint8_t data) {
-  return ring_buf_put(&txRingBuffer.rb, &data, 1);
+    return ring_buf_put(&txRingBuffer.rb, &data, 1);
 }
 
 size_t arduino::ZephyrI2C::write(const uint8_t *buffer, size_t size) {
-  return ring_buf_put(&txRingBuffer.rb, buffer, size);
+    return ring_buf_put(&txRingBuffer.rb, buffer, size);
 }
 
 int arduino::ZephyrI2C::read() {
-  uint8_t buf;
-  if (ring_buf_get(&rxRingBuffer.rb, &buf, 1)) {
-    return (int) buf;
-  }
-  return -1;
+    uint8_t buf;
+    if (ring_buf_get(&rxRingBuffer.rb, &buf, 1)) {
+        return (int) buf;
+    }
+    return -1;
 }
 
 int arduino::ZephyrI2C::available() {
-  return ring_buf_size_get(&rxRingBuffer.rb);
+    return ring_buf_size_get(&rxRingBuffer.rb);
 }
 
 int arduino::ZephyrI2C::peek() {
-  uint8_t buf;
-  if (ring_buf_peek(&rxRingBuffer.rb, &buf, 1)) {
-    return (int) buf;
-  } 
-  return -1;
+    uint8_t buf;
+    if (ring_buf_peek(&rxRingBuffer.rb, &buf, 1)) {
+        return (int) buf;
+    } 
+    return -1;
 }
 
 void arduino::ZephyrI2C::flush() {
 
 }
 
 void arduino::ZephyrI2C::onReceive(voidFuncPtrParamInt cb) {
-  onReceiveCb = cb;
+    onReceiveCb = cb;
 }
 
 void arduino::ZephyrI2C::onRequest(voidFuncPtr cb) {
-  onRequestCb = cb;
+    onRequestCb = cb;
 }
 
 int arduino::ZephyrI2C::writeRequestedCallback(struct i2c_target_config *config) {
-  // Reset the buffer on write requests.
-  ring_buf_reset(&rxRingBuffer.rb);
-  return 0;
+    // Reset the buffer on write requests.
+    ring_buf_reset(&rxRingBuffer.rb);
+    return 0;
 }
 
 int arduino::ZephyrI2C::writeReceivedCallback(struct i2c_target_config *config, uint8_t val) {
-  size_t len = ring_buf_size_get(&rxRingBuffer.rb);
-  size_t max = ring_buf_capacity_get(&rxRingBuffer.rb);
+    size_t len = ring_buf_size_get(&rxRingBuffer.rb);
+    size_t max = ring_buf_capacity_get(&rxRingBuffer.rb);
 
-  // If the buffer is about to overflow, invoke the callback
-  // with the current length.
-  if (onReceiveCb && ((len + 1) > max)) {
-    onReceiveCb(len);
-  }
+    // If the buffer is about to overflow, invoke the callback
+    // with the current length.
+    if (onReceiveCb && ((len + 1) > max)) {
+        onReceiveCb(len);
+    }
 
-  return ring_buf_put(&rxRingBuffer.rb, &val, 1) ? 0 : -1;
+    return ring_buf_put(&rxRingBuffer.rb, &val, 1) ? 0 : -1;
 }
 
 int arduino::ZephyrI2C::readRequestedCallback(struct i2c_target_config *config, uint8_t *val) {
-  // Reset the buffer on read requests.
-  ring_buf_reset(&txRingBuffer.rb);
+    // Reset the buffer on read requests.
+    ring_buf_reset(&txRingBuffer.rb);
 
-  if (onRequestCb) {
-    onRequestCb();
-  }
+    if (onRequestCb) {
+        onRequestCb();
+    }
 
-  return readProcessedCallback(config, val);
+    return readProcessedCallback(config, val);
 }
 
 int arduino::ZephyrI2C::readProcessedCallback(struct i2c_target_config *config, uint8_t *val) {
-  *val = 0xFF;
-  ring_buf_get(&txRingBuffer.rb, val, 1);
-  // Returning a negative value here is not handled gracefully and
-  // causes the target/board to stop responding (at least with ST).
-  return 0;
+    *val = 0xFF;
+    ring_buf_get(&txRingBuffer.rb, val, 1);
+    // Returning a negative value here is not handled gracefully and
+    // causes the target/board to stop responding (at least with ST).
+    return 0;
 }
 
 int arduino::ZephyrI2C::stopCallback(struct i2c_target_config *config) {
-  // If the RX buffer is not empty invoke the callback with the
-  // remaining data length.
-  if (onReceiveCb) {
-    size_t len = ring_buf_size_get(&rxRingBuffer.rb);
-    if (len) {
-        onReceiveCb(len);
+    // If the RX buffer is not empty invoke the callback with the
+    // remaining data length.
+    if (onReceiveCb) {
+        size_t len = ring_buf_size_get(&rxRingBuffer.rb);
+        if (len) {
+            onReceiveCb(len);
+        }
     }
-  }
-  return 0;
+    return 0;
 }
 
 #if DT_NODE_HAS_PROP(DT_PATH(zephyr_user), i2cs)

libraries/Wire/Wire.h

@@ -16,56 +16,56 @@ typedef void (*voidFuncPtrParamInt)(int);
 namespace arduino {
 
 struct i2c_ring {
-  struct ring_buf rb;
-  uint8_t buffer[256];
+    struct ring_buf rb;
+    uint8_t buffer[256];
 };
 
 class ZephyrI2C : public HardwareI2C {
-public:
-  ZephyrI2C(const struct device* i2c);
-
-  virtual void begin();
-  virtual void end();
-  virtual void begin(uint8_t address);
-  virtual void setClock(uint32_t freq);
-
-  virtual void beginTransmission(uint8_t address);
-  virtual uint8_t endTransmission(bool stopBit);
-  virtual uint8_t endTransmission(void);
-
-  virtual size_t requestFrom(uint8_t address, size_t len, bool stopBit);
-  virtual size_t requestFrom(uint8_t address, size_t len);
-
-  virtual void onReceive(void (*)(int));
-  virtual void onRequest(void (*)(void));
-
-  virtual size_t write(uint8_t data);
-  virtual size_t write(int data) { return write((uint8_t)data); };
-  virtual size_t write(const uint8_t *buffer, size_t size);
-  using Print::write;
-  virtual int read();
-  virtual int peek();
-  virtual void flush();
-  virtual int available();
-
-  // I2C target callbacks
-  int writeRequestedCallback(struct i2c_target_config *config);
-  int writeReceivedCallback(struct i2c_target_config *config, uint8_t val);
-  int readRequestedCallback(struct i2c_target_config *config, uint8_t *val);
-  int readProcessedCallback(struct i2c_target_config *config, uint8_t *val);
-  int stopCallback(struct i2c_target_config *config);
-
-  struct i2c_target_config i2c_cfg;
-
-private:
-  int _address;
-
-  struct i2c_ring txRingBuffer;
-  struct i2c_ring rxRingBuffer;
-  const struct device *i2c_dev;
-
-  voidFuncPtr onRequestCb = NULL;
-  voidFuncPtrParamInt onReceiveCb = NULL;
+    public:
+        ZephyrI2C(const struct device* i2c);
+
+        virtual void begin();
+        virtual void end();
+        virtual void begin(uint8_t address);
+        virtual void setClock(uint32_t freq);
+
+        virtual void beginTransmission(uint8_t address);
+        virtual uint8_t endTransmission(bool stopBit);
+        virtual uint8_t endTransmission(void);
+
+        virtual size_t requestFrom(uint8_t address, size_t len, bool stopBit);
+        virtual size_t requestFrom(uint8_t address, size_t len);
+
+        virtual void onReceive(void (*)(int));
+        virtual void onRequest(void (*)(void));
+
+        virtual size_t write(uint8_t data);
+        virtual size_t write(int data) { return write((uint8_t)data); };
+        virtual size_t write(const uint8_t *buffer, size_t size);
+        using Print::write;
+        virtual int read();
+        virtual int peek();
+        virtual void flush();
+        virtual int available();
+
+        // I2C target callbacks
+        int writeRequestedCallback(struct i2c_target_config *config);
+        int writeReceivedCallback(struct i2c_target_config *config, uint8_t val);
+        int readRequestedCallback(struct i2c_target_config *config, uint8_t *val);
+        int readProcessedCallback(struct i2c_target_config *config, uint8_t *val);
+        int stopCallback(struct i2c_target_config *config);
+
+        struct i2c_target_config i2c_cfg;
+
+    private:
+        int _address;
+
+        struct i2c_ring txRingBuffer;
+        struct i2c_ring rxRingBuffer;
+        const struct device *i2c_dev;
+
+        voidFuncPtr onRequestCb = NULL;
+        voidFuncPtrParamInt onReceiveCb = NULL;
 };
 
 } // namespace arduino
@@ -75,7 +75,7 @@ class ZephyrI2C : public HardwareI2C {
 #define DECL_EXTERN_WIRE_0(i)  extern arduino::ZephyrI2C Wire;
 #define DECL_EXTERN_WIRE_N(i)  extern arduino::ZephyrI2C Wire##i;
 #define DECLARE_EXTERN_WIRE_N(n, p, i)                                                             \
-	COND_CODE_1(ARDUINO_WIRE_DEFINED_##i, (DECL_EXTERN_WIRE_0(i)), (DECL_EXTERN_WIRE_N(i)))
+    COND_CODE_1(ARDUINO_WIRE_DEFINED_##i, (DECL_EXTERN_WIRE_0(i)), (DECL_EXTERN_WIRE_N(i)))
 
 /* Declare Wire, Wire1, Wire2, ... */
 DT_FOREACH_PROP_ELEM(DT_PATH(zephyr_user), i2cs, DECLARE_EXTERN_WIRE_N)
@@ -85,7 +85,7 @@ DT_FOREACH_PROP_ELEM(DT_PATH(zephyr_user), i2cs, DECLARE_EXTERN_WIRE_N)
 #undef DECL_EXTERN_WIRE_0
 #undef ARDUINO_WIRE_DEFINED_0
 #else
-extern arduino::ZephyrI2C Wire;
+    extern arduino::ZephyrI2C Wire;
 #endif
 
-typedef arduino::ZephyrI2C TwoWire;
+    typedef arduino::ZephyrI2C TwoWire;