clang format

Author: hathach

src/arduino/Adafruit_TinyUSB_API.cpp

@@ -31,28 +31,25 @@
 //--------------------------------------------------------------------+
 // MACRO TYPEDEF CONSTANT ENUM DECLARATION
 //--------------------------------------------------------------------+
-extern "C"
-{
+extern "C" {
 
-void TinyUSB_Device_Init(uint8_t rhport)
-{
+void TinyUSB_Device_Init(uint8_t rhport) {
+  // Init USB Device controller and stack
   USBDevice.begin(rhport);
 }
 
 // RP2040 has its own implementation since it needs mutex for dual core
 #ifndef ARDUINO_ARCH_RP2040
-void TinyUSB_Device_Task(void)
-{
+void TinyUSB_Device_Task(void) {
+  // Run tinyusb device task
   tud_task();
 }
 #endif
 
-void TinyUSB_Device_FlushCDC(void)
-{
+void TinyUSB_Device_FlushCDC(void) {
   // TODO multiple CDCs
   tud_cdc_n_write_flush(0);
 }
-
 }
 
 #endif

src/arduino/Adafruit_TinyUSB_API.h

@@ -25,16 +25,16 @@
 #ifndef ADAFRUIT_TINYUSB_API_H_
 #define ADAFRUIT_TINYUSB_API_H_
 
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 //--------------------------------------------------------------------+
 // Core API
 // Should be called by BSP Core to initialize, process task
 // Weak function allow compile arduino core before linking with this library
 //--------------------------------------------------------------------+
 #ifdef __cplusplus
- extern "C" {
+extern "C" {
 #endif
 
 // Called by core/sketch to initialize usb device hardware and stack
@@ -48,7 +48,7 @@ void TinyUSB_Device_Task(void) __attribute__((weak));
 void TinyUSB_Device_FlushCDC(void) __attribute__((weak));
 
 #ifdef __cplusplus
- }
+}
 #endif
 
 //--------------------------------------------------------------------+

src/arduino/Adafruit_USBD_CDC.cpp

@@ -27,186 +27,169 @@
 #if TUSB_OPT_DEVICE_ENABLED && CFG_TUD_CDC
 
 #include "Arduino.h"
+
 #include "Adafruit_TinyUSB_API.h"
 
-#include "Adafruit_USBD_Device.h"
 #include "Adafruit_USBD_CDC.h"
+#include "Adafruit_USBD_Device.h"
 
 // TODO Multiple instances supports
 //	static uint8_t _itf_count;
 //	static Adafruit_USBD_CDC* _itf_arr[]
 
-#define EPOUT   0x00
-#define EPIN    0x80
+#define EPOUT 0x00
+#define EPIN 0x80
 
 Adafruit_USBD_CDC Serial;
 
-Adafruit_USBD_CDC::Adafruit_USBD_CDC(void)
-{
+Adafruit_USBD_CDC::Adafruit_USBD_CDC(void) {
   _begun = false;
   _itf = 0;
 }
 
-uint16_t Adafruit_USBD_CDC::getInterfaceDescriptor(uint8_t itfnum, uint8_t* buf, uint16_t bufsize)
-{
+uint16_t Adafruit_USBD_CDC::getInterfaceDescriptor(uint8_t itfnum, uint8_t *buf,
+                                                   uint16_t bufsize) {
   // CDC is mostly always existed for DFU
   // usb core will automatically update endpoint number
-  uint8_t desc[] = { TUD_CDC_DESCRIPTOR(itfnum, 0, EPIN, 8, EPOUT, EPIN, 64) };
+  uint8_t desc[] = {TUD_CDC_DESCRIPTOR(itfnum, 0, EPIN, 8, EPOUT, EPIN, 64)};
   uint16_t const len = sizeof(desc);
 
-  if ( bufsize < len ) return 0;
+  if (bufsize < len) {
+    return 0;
+  }
 
   memcpy(buf, desc, len);
   return len;
 }
 
 // Baud and config is ignore in CDC
-void Adafruit_USBD_CDC::begin (uint32_t baud)
-{
-  (void) baud;
+void Adafruit_USBD_CDC::begin(uint32_t baud) {
+  (void)baud;
+
+  if (_begun) {
+    return;
+  }
 
-  if (_begun) return;
   _begun = true;
 
   Serial.setStringDescriptor("TinyUSB Serial");
   USBDevice.addInterface(Serial);
 }
 
-void Adafruit_USBD_CDC::begin (uint32_t baud, uint8_t config)
-{
-  (void) config;
+void Adafruit_USBD_CDC::begin(uint32_t baud, uint8_t config) {
+  (void)config;
   this->begin(baud);
 }
 
-void Adafruit_USBD_CDC::end(void)
-{
+void Adafruit_USBD_CDC::end(void) {
+  // Resset configuration descriptor without Serial as CDC
   USBDevice.clearConfiguration();
 }
 
-uint32_t Adafruit_USBD_CDC::baud(void)
-{
+uint32_t Adafruit_USBD_CDC::baud(void) {
   cdc_line_coding_t coding;
   tud_cdc_get_line_coding(&coding);
 
   return coding.bit_rate;
 }
 
-uint8_t Adafruit_USBD_CDC::stopbits(void)
-{
+uint8_t Adafruit_USBD_CDC::stopbits(void) {
   cdc_line_coding_t coding;
   tud_cdc_get_line_coding(&coding);
 
   return coding.stop_bits;
 }
 
-uint8_t Adafruit_USBD_CDC::paritytype(void)
-{
+uint8_t Adafruit_USBD_CDC::paritytype(void) {
   cdc_line_coding_t coding;
   tud_cdc_get_line_coding(&coding);
 
   return coding.parity;
 }
 
-uint8_t Adafruit_USBD_CDC::numbits(void)
-{
+uint8_t Adafruit_USBD_CDC::numbits(void) {
   cdc_line_coding_t coding;
   tud_cdc_get_line_coding(&coding);
 
   return coding.data_bits;
 }
 
-int Adafruit_USBD_CDC::dtr(void)
-{
-  return tud_cdc_connected();
-}
+int Adafruit_USBD_CDC::dtr(void) { return tud_cdc_connected(); }
 
-Adafruit_USBD_CDC::operator bool()
-{
+Adafruit_USBD_CDC::operator bool() {
   bool ret = tud_cdc_connected();
 
   // Add an yield to run usb background in case sketch block wait as follows
   // while( !Serial ) {}
-  if ( !ret ) yield();
-
+  if (!ret) {
+    yield();
+  }
   return ret;
 }
 
-int Adafruit_USBD_CDC::available(void)
-{
+int Adafruit_USBD_CDC::available(void) {
   uint32_t count = tud_cdc_available();
 
   // Add an yield to run usb background in case sketch block wait as follows
   // while( !Serial.available() ) {}
-  if (!count) yield();
+  if (!count) {
+    yield();
+  }
 
   return count;
 }
 
-int Adafruit_USBD_CDC::peek(void)
-{
+int Adafruit_USBD_CDC::peek(void) {
   uint8_t ch;
-  return tud_cdc_peek(&ch) ? (int) ch : -1;
+  return tud_cdc_peek(&ch) ? (int)ch : -1;
 }
 
-int Adafruit_USBD_CDC::read(void)
-{
-  return (int) tud_cdc_read_char();
-}
+int Adafruit_USBD_CDC::read(void) { return (int)tud_cdc_read_char(); }
 
-void Adafruit_USBD_CDC::flush(void)
-{
-  tud_cdc_write_flush();
-}
+void Adafruit_USBD_CDC::flush(void) { tud_cdc_write_flush(); }
 
-size_t Adafruit_USBD_CDC::write(uint8_t ch)
-{
-  return write(&ch, 1);
-}
+size_t Adafruit_USBD_CDC::write(uint8_t ch) { return write(&ch, 1); }
 
-size_t Adafruit_USBD_CDC::write(const uint8_t *buffer, size_t size)
-{
+size_t Adafruit_USBD_CDC::write(const uint8_t *buffer, size_t size) {
   size_t remain = size;
-  while ( remain && tud_cdc_connected() )
-  {
+  while (remain && tud_cdc_connected()) {
     size_t wrcount = tud_cdc_write(buffer, remain);
     remain -= wrcount;
     buffer += wrcount;
 
     // Write FIFO is full, run usb background to flush
-    if ( remain ) yield();
+    if (remain) {
+      yield();
+    }
   }
 
   return size - remain;
 }
 
-int Adafruit_USBD_CDC::availableForWrite(void)
-{
+int Adafruit_USBD_CDC::availableForWrite(void) {
   return tud_cdc_write_available();
 }
 
-extern "C"
-{
+extern "C" {
 
 // Invoked when cdc when line state changed e.g connected/disconnected
 // Use to reset to DFU when disconnect with 1200 bps
-void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
-{
-  (void) rts;
+void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts) {
+  (void)rts;
 
   // DTR = false is counted as disconnected
-  if ( !dtr )
-  {
+  if (!dtr) {
     // touch1200 only with first CDC instance (Serial)
-    if ( itf == 0 )
-    {
+    if (itf == 0) {
       cdc_line_coding_t coding;
       tud_cdc_get_line_coding(&coding);
 
-      if ( coding.bit_rate == 1200 ) TinyUSB_Port_EnterDFU();
+      if (coding.bit_rate == 1200) {
+        TinyUSB_Port_EnterDFU();
+      }
     }
   }
 }
-
 }
 
 #endif // TUSB_OPT_DEVICE_ENABLED

src/arduino/Adafruit_USBD_CDC.h

@@ -29,48 +29,51 @@
 
 #ifdef __cplusplus
 
-#include "Stream.h"
 #include "Adafruit_USBD_Interface.h"
+#include "Stream.h"
 
-class Adafruit_USBD_CDC : public Stream, public Adafruit_USBD_Interface
-{
+class Adafruit_USBD_CDC : public Stream, public Adafruit_USBD_Interface {
 public:
-	Adafruit_USBD_CDC(void);
+  Adafruit_USBD_CDC(void);
 
-	// fron Adafruit_USBD_Interface
-	virtual uint16_t getInterfaceDescriptor(uint8_t itfnum, uint8_t* buf, uint16_t bufsize);
+  // fron Adafruit_USBD_Interface
+  virtual uint16_t getInterfaceDescriptor(uint8_t itfnum, uint8_t *buf,
+                                          uint16_t bufsize);
 
-	void setPins(uint8_t pin_rx, uint8_t pin_tx) { (void) pin_rx; (void) pin_tx; }
-	void begin(uint32_t baud);
-	void begin(uint32_t baud, uint8_t config);
-	void end(void);
+  void setPins(uint8_t pin_rx, uint8_t pin_tx) {
+    (void)pin_rx;
+    (void)pin_tx;
+  }
+  void begin(uint32_t baud);
+  void begin(uint32_t baud, uint8_t config);
+  void end(void);
 
-	// return line coding set by host
-	uint32_t baud(void);
-	uint8_t  stopbits(void);
-	uint8_t  paritytype(void);
-	uint8_t  numbits(void);
-	int      dtr(void);
+  // return line coding set by host
+  uint32_t baud(void);
+  uint8_t stopbits(void);
+  uint8_t paritytype(void);
+  uint8_t numbits(void);
+  int dtr(void);
 
-	// Stream API
-	virtual int    available(void);
-	virtual int    peek(void);
-	virtual int    read(void);
-	virtual void   flush(void);
-	virtual size_t write(uint8_t);
+  // Stream API
+  virtual int available(void);
+  virtual int peek(void);
+  virtual int read(void);
+  virtual void flush(void);
+  virtual size_t write(uint8_t);
 
-	virtual size_t write(const uint8_t *buffer, size_t size);
-	size_t write(const char *buffer, size_t size) {
-	  return write((const uint8_t *)buffer, size);
-	}
+  virtual size_t write(const uint8_t *buffer, size_t size);
+  size_t write(const char *buffer, size_t size) {
+    return write((const uint8_t *)buffer, size);
+  }
 
-	virtual int availableForWrite(void);
-	using Print::write; // pull in write(str) from Print
-	operator bool();
+  virtual int availableForWrite(void);
+  using Print::write; // pull in write(str) from Print
+  operator bool();
 
 private:
-	bool    _begun;
-	uint8_t _itf;
+  bool _begun;
+  uint8_t _itf;
 };
 
 extern Adafruit_USBD_CDC Serial;