Opening brace tweaks

Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp

   #include <Arduino.h>
   #include "../../core/macros.h"
 
-
   void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index) {
      PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,
        g_APinDescription[u8g->pin_list[pin_index]].ulPin, g_APinDescription[u8g->pin_list[pin_index]].ulPinConfiguration);  // OUTPUT
   }
 
-
   void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
     volatile Pio* port = g_APinDescription[u8g->pin_list[pin_index]].pPort;
     uint32_t mask = g_APinDescription[u8g->pin_list[pin_index]].ulPin;
     else port->PIO_CODR = mask;
   }
 
-
 #define nop() __asm__ __volatile__("nop;\n\t":::)
 
 void __delay_4cycles(uint32_t cy) __attribute__ ((weak));
   Pio *SCK_pPio, *MOSI_pPio;
   uint32_t SCK_dwMask, MOSI_dwMask;
 
-  static void spiSend_sw_DUE(uint8_t val)  // 800KHz
-  {
+  static void spiSend_sw_DUE(uint8_t val) { // 800KHz
     for (uint8_t i = 0; i < 8; i++) {
       if (val & 0x80)
         MOSI_pPio->PIO_SODR = MOSI_dwMask;
 
   static uint8_t rs_last_state = 255;
 
-  static void u8g_com_DUE_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val)
-  {
+  static void u8g_com_DUE_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val) {
     uint8_t i;
 
     if ( rs != rs_last_state) {  // time to send a command/data byte
   }
 
 
-  uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-  {
-    switch(msg)
-    {
+  uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
+    switch (msg) {
       case U8G_COM_MSG_INIT:
         SCK_pPio = g_APinDescription[u8g->pin_list[U8G_PI_SCK]].pPort;
         SCK_dwMask = g_APinDescription[u8g->pin_list[U8G_PI_SCK]].ulPin;
         u8g_com_DUE_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
         break;
 
-      case U8G_COM_MSG_WRITE_SEQ:
-        {
+      case U8G_COM_MSG_WRITE_SEQ: {
           uint8_t *ptr = (uint8_t*) arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             u8g_com_DUE_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
             arg_val--;
           }
         }
         break;
 
-        case U8G_COM_MSG_WRITE_SEQ_P:
-        {
+        case U8G_COM_MSG_WRITE_SEQ_P: {
           uint8_t *ptr = (uint8_t*) arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             u8g_com_DUE_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
             arg_val--;
           }
     }
     return 1;
   }
+
 #pragma GCC reset_options
+
 #endif  //ARDUINO_ARCH_SAM

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_hw_spi.cpp

         spiSend((uint8_t)arg_val);
         break;
 
-      case U8G_COM_MSG_WRITE_SEQ:
-        {
+      case U8G_COM_MSG_WRITE_SEQ: {
           uint8_t *ptr = (uint8_t*) arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             spiSend(*ptr++);
             arg_val--;
           }
         }
         break;
 
-      case U8G_COM_MSG_WRITE_SEQ_P:
-        {
+      case U8G_COM_MSG_WRITE_SEQ_P: {
           uint8_t *ptr = (uint8_t*) arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             spiSend(*ptr++);
             arg_val--;
           }

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_hw_i2c.cpp

           return u8g_i2c_stop(), 0;
         {
           register uint8_t *ptr = (uint8_t *)arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             if ( u8g_i2c_send_byte(*ptr++) == 0 )
               return u8g_i2c_stop(), 0;
             arg_val--;
           return u8g_i2c_stop(), 0;
         {
           register uint8_t *ptr = (uint8_t *)arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             if ( u8g_i2c_send_byte(u8g_pgm_read(ptr)) == 0 )
               return 0;
             ptr++;

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_sw_i2c.cpp under construction

           return u8g_i2c_stop_sw(), 0;
         {
           register uint8_t *ptr = (uint8_t *)arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             if ( u8g_i2c_send_byte_sw(*ptr++) == 0 )
               return u8g_i2c_stop_sw(), 0;
             arg_val--;
           return u8g_i2c_stop_sw(), 0;
         {
           register uint8_t *ptr = (uint8_t *)arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             if ( u8g_i2c_send_byte_sw(u8g_pgm_read(ptr)) == 0 )
               return 0;
             ptr++;

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_hw_spi.cpp

         u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
         break;
 
-      case U8G_COM_MSG_WRITE_SEQ:
-        {
+      case U8G_COM_MSG_WRITE_SEQ: {
           uint8_t *ptr = (uint8_t*) arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
             arg_val--;
           }
         }
         break;
 
-        case U8G_COM_MSG_WRITE_SEQ_P:
-        {
+        case U8G_COM_MSG_WRITE_SEQ_P: {
           uint8_t *ptr = (uint8_t*) arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
             arg_val--;
           }

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_sw_spi.cpp

         u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
         break;
 
-      case U8G_COM_MSG_WRITE_SEQ:
-        {
+      case U8G_COM_MSG_WRITE_SEQ: {
           uint8_t *ptr = (uint8_t*) arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
             arg_val--;
           }
         }
         break;
 
-        case U8G_COM_MSG_WRITE_SEQ_P:
-        {
+        case U8G_COM_MSG_WRITE_SEQ_P: {
           uint8_t *ptr = (uint8_t*) arg_ptr;
-          while( arg_val > 0 )
-          {
+          while (arg_val > 0) {
             u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
             arg_val--;
           }

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_sw_spi.cpp

       u8g_sw_spi_HAL_LPC1768_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
       break;
 
-    case U8G_COM_MSG_WRITE_SEQ:
-      {
+    case U8G_COM_MSG_WRITE_SEQ: {
         uint8_t *ptr = (uint8_t *)arg_ptr;
-        while( arg_val > 0 )
-        {
+        while (arg_val > 0) {
           u8g_sw_spi_HAL_LPC1768_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], *ptr++);
           arg_val--;
         }
       }
       break;
 
-      case U8G_COM_MSG_WRITE_SEQ_P:
-      {
+      case U8G_COM_MSG_WRITE_SEQ_P: {
         uint8_t *ptr = (uint8_t *)arg_ptr;
-        while( arg_val > 0 )
-        {
+        while (arg_val > 0) {
           u8g_sw_spi_HAL_LPC1768_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], u8g_pgm_read(ptr));
           ptr++;
           arg_val--;

Marlin/src/gcode/feature/trinamic/M122.cpp

 #if ENABLED(HAVE_TMC2208)
   static void tmc_status(TMC2208Stepper &st, const TMC_debug_enum i) {
     switch(i) {
-      case TMC_TSTEP:
-        {
+      case TMC_TSTEP: {
           uint32_t data = 0;
           st.TSTEP(&data);
           MYSERIAL.print(data);
     case TMC_VSENSE: serialprintPGM(st.vsense() ? PSTR("1=.18") : PSTR("0=.325")); break;
 
     case TMC_MICROSTEPS: SERIAL_ECHO(st.microsteps()); break;
-    case TMC_TPWMTHRS:
-      {
+    case TMC_TPWMTHRS: {
         uint32_t tpwmthrs_val = st.TPWMTHRS();
         SERIAL_ECHO(tpwmthrs_val);
       }
       break;
-    case TMC_TPWMTHRS_MMS:
-      {
+    case TMC_TPWMTHRS_MMS: {
         uint32_t tpwmthrs_val = st.TPWMTHRS();
         tpwmthrs_val ? SERIAL_ECHO(12650000UL * st.microsteps() / (256 * tpwmthrs_val * spmm)) : SERIAL_ECHO('-');
       }

Marlin/src/lcd/dogm/u8g_dev_ssd1306_sh1106_128x64_I2C.cpp

       break;
     case U8G_DEV_MSG_STOP:
       break;
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
+    case U8G_DEV_MSG_PAGE_NEXT: {
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
         u8g_SetAddress(u8g, dev, 0);           // instruction mode
         u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_sh1106_128x64_data_start_2_wire);
       break;
     case U8G_DEV_MSG_STOP:
       break;
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
+    case U8G_DEV_MSG_PAGE_NEXT: {
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
         u8g_SetAddress(u8g, dev, 0);           // instruction mode
         u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_ssd1306_128x64_data_start_2_wire);

Marlin/src/lcd/dogm/u8g_dev_st7565_64128n_HAL.cpp

       break;
     case U8G_DEV_MSG_STOP:
       break;
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
+    case U8G_DEV_MSG_PAGE_NEXT: {
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);
         u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
       break;
     case U8G_DEV_MSG_STOP:
       break;
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
+    case U8G_DEV_MSG_PAGE_NEXT: {
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
 
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);

Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp

       break;
     case U8G_DEV_MSG_STOP:
       break;
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
+    case U8G_DEV_MSG_PAGE_NEXT: {
         uint8_t y, i;
         uint8_t *ptr;
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
     case U8G_DEV_MSG_STOP:
       break;
 
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
+    case U8G_DEV_MSG_PAGE_NEXT: {
         uint8_t y, i;
         uint8_t *ptr;
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);