Astyle formatting

features/nfc/acore/acore/buffer.h

@@ -37,8 +37,7 @@ extern "C" {
 #include "stddef.h"
 #include "stdbool.h"
 
-typedef struct __ac_buffer
+typedef struct __ac_buffer {
-{
     const uint8_t *data;
     size_t size;
     struct __ac_buffer *pNext;

features/nfc/acore/acore/buffer_builder.h

@@ -39,8 +39,7 @@ extern "C" {
 
 #include "acore/buffer.h"
 
-typedef struct __ac_buffer_builder
+typedef struct __ac_buffer_builder {
-{
     ac_buffer_t ac_buffer;
     uint8_t *data;
     size_t size;
@@ -113,8 +112,7 @@ static inline size_t ac_buffer_builder_length(ac_buffer_builder_t* pBuilder)
  */
 static inline void ac_buffer_builder_set_length(ac_buffer_builder_t *pBuilder, size_t length)
 {
-  if( ac_buffer_data(&pBuilder->ac_buffer) + length > pBuilder->data + pBuilder->size )
+    if (ac_buffer_data(&pBuilder->ac_buffer) + length > pBuilder->data + pBuilder->size) {
-  {
         return;
     }
     pBuilder->ac_buffer.size = length;
@@ -144,16 +142,12 @@ static inline size_t ac_buffer_builder_write_offset(ac_buffer_builder_t* pBuilde
  */
 static inline void ac_buffer_builder_set_write_offset(ac_buffer_builder_t *pBuilder, size_t off)
 {
-  if( off > pBuilder->size )
+    if (off > pBuilder->size) {
-  {
         return;
     }
-  if( pBuilder->data + off > pBuilder->ac_buffer.data )
+    if (pBuilder->data + off > pBuilder->ac_buffer.data) {
-  {
         pBuilder->ac_buffer.size = off - (pBuilder->ac_buffer.data - pBuilder->data);
-  }
+    } else {
-  else
-  {
         pBuilder->ac_buffer.size = 0;
     }
 }
@@ -173,16 +167,12 @@ static inline size_t ac_buffer_builder_read_offset(ac_buffer_builder_t* pBuilder
  */
 static inline void ac_buffer_builder_set_read_offset(ac_buffer_builder_t *pBuilder, size_t off)
 {
-  if( off > pBuilder->size )
+    if (off > pBuilder->size) {
-  {
         return;
     }
-  if( pBuilder->data + off < pBuilder->ac_buffer.data + pBuilder->ac_buffer.size )
+    if (pBuilder->data + off < pBuilder->ac_buffer.data + pBuilder->ac_buffer.size) {
-  {
         pBuilder->ac_buffer.size = pBuilder->ac_buffer.data - (pBuilder->data + off);
-  }
+    } else {
-  else
-  {
         pBuilder->ac_buffer.size = 0;
     }
     pBuilder->ac_buffer.data = pBuilder->data + off;

features/nfc/acore/acore/stream.h

@@ -43,15 +43,13 @@ typedef void (*ac_istream_fn)(ac_buffer_t* pDataIn, bool* pClose, size_t maxLeng
 typedef void (*ac_ostream_fn)(ac_buffer_t *pDataOut, bool closed, void *pUserParam);
 
 //Input stream -- pulled by consumer
-struct __ac_istream
+struct __ac_istream {
-{
     ac_istream_fn fn;
     void *pUserParam;
 };
 
 //Output stream -- pushed by supplier
-struct __ac_ostream
+struct __ac_ostream {
-{
     ac_ostream_fn fn;
     void *pUserParam;
 };

features/nfc/acore/source/buffer.c

@@ -39,16 +39,14 @@ void ac_buffer_init(ac_buffer_t* pBuf, const uint8_t* data, size_t size)
 
 void ac_buffer_dup(ac_buffer_t *pBuf, const ac_buffer_t *pBufIn)
 {
-  if(pBuf != pBufIn)
+    if (pBuf != pBufIn) {
-  {
         memcpy(pBuf, pBufIn, sizeof(ac_buffer_t));
     }
 }
 
 void ac_buffer_append(ac_buffer_t *pBuf, ac_buffer_t *pAppBuf)
 {
-  while(pBuf->pNext != NULL)
+    while (pBuf->pNext != NULL) {
-  {
         pBuf = pBuf->pNext;
     }
     pBuf->pNext = pAppBuf;
@@ -61,8 +59,7 @@ void ac_buffer_split(ac_buffer_t* pStartBuf, ac_buffer_t* pEndBuf, ac_buffer_t*
 
     ac_buffer_read_n_skip(pEndBuf, length);
 
-  while( length > ac_buffer_size(pStartBuf) )
+    while (length > ac_buffer_size(pStartBuf)) {
-  {
         length -= pStartBuf->size;
         pStartBuf = pStartBuf->pNext;
     }
@@ -78,23 +75,19 @@ void ac_buffer_dump(ac_buffer_t* pBuf)
 {
 #if !defined(NDEBUG)
     ACORE_STDIO_LOCK();
-  while(pBuf != NULL)
+    while (pBuf != NULL) {
-  {
         size_t r = ac_buffer_size(pBuf);
         size_t i = 0;
         size_t j = 0;
-    while(i < r)
+        while (i < r) {
-    {
+            for (j = i; j < MIN(i + 16, r); j++) {
-      for(j = i; j < MIN(i + 16, r); j++)
-      {
                 ACORE_STDIO_PRINT("%02x ", ac_buffer_data(pBuf)[j]);
             }
             ACORE_STDIO_PRINT("\r\n");
             i = j;
         }
         pBuf = ac_buffer_next(pBuf);
-    if(pBuf != NULL)
+        if (pBuf != NULL) {
-    {
             ACORE_STDIO_PRINT("->\r\n");
         }
     }

features/nfc/acore/source/buffer_builder.c

@@ -57,8 +57,7 @@ void ac_buffer_builder_write_be(ac_buffer_builder_t* pBuilder, const uint8_t* bu
 {
     ENSURE_WRITE_LENGTH(pBuilder, size);
     buf += size;
-  while(size > 0)
+    while (size > 0) {
-  {
         buf--;
         *ac_buffer_builder_write_position(pBuilder) = *buf;
         pBuilder->ac_buffer.size++;
@@ -98,12 +97,10 @@ void ac_buffer_builder_write_n_skip(ac_buffer_builder_t* pBuilder, size_t size)
 void ac_buffer_builder_copy_n_bytes(ac_buffer_builder_t *pBuilderOut, ac_buffer_t *pBufIn, size_t size)
 {
     ENSURE_WRITE_LENGTH(pBuilderOut, size);
-  if( ac_buffer_reader_readable(pBufIn) < size )
+    if (ac_buffer_reader_readable(pBufIn) < size) {
-  {
         return;
     }
-  while(size > 0)
+    while (size > 0) {
-  {
         size_t cpy = ac_buffer_reader_current_buffer_length(pBufIn);
         cpy = MIN(cpy, size);
         ac_buffer_builder_write_n_bytes(pBuilderOut, ac_buffer_reader_current_buffer_pointer(pBufIn), cpy);

features/nfc/acore/source/buffer_reader.c

@@ -30,20 +30,14 @@
 
 static inline void update_buf(ac_buffer_t *pBuf)
 {
-  while( ac_buffer_size(pBuf) == 0 )
+    while (ac_buffer_size(pBuf) == 0) {
-  {
+        if (ac_buffer_next(pBuf) != NULL) {
-    if( ac_buffer_next(pBuf) != NULL )
-    {
             ac_buffer_t *pNext = ac_buffer_next(pBuf);
             ac_buffer_init(pBuf, ac_buffer_data(pNext), ac_buffer_size(pNext));
             pBuf->pNext = ac_buffer_next(pNext);
-    }
+        } else if (pBuf->data != NULL) {
-    else if( pBuf->data != NULL )
-    {
             ac_buffer_init(pBuf, NULL, 0);
-    }
+        } else {
-    else
-    {
             return;
         }
     }
@@ -53,8 +47,7 @@ void ac_buffer_read_be(ac_buffer_t* pBuf, uint8_t* buf, size_t size)
 {
     ENSURE_READ_LENGTH(pBuf, size);
     buf += size;
-  while(size > 0)
+    while (size > 0) {
-  {
         buf--;
         *buf = *ac_buffer_data(pBuf);
         pBuf->data++;
@@ -67,8 +60,7 @@ void ac_buffer_read_be(ac_buffer_t* pBuf, uint8_t* buf, size_t size)
 void ac_buffer_read_le(ac_buffer_t *pBuf, uint8_t *buf, size_t size)
 {
     ENSURE_READ_LENGTH(pBuf, size);
-  while(size > 0)
+    while (size > 0) {
-  {
         size_t cpy = ac_buffer_size(pBuf);
         cpy = MIN(cpy, size);
         memcpy(buf, ac_buffer_data(pBuf), cpy);
@@ -83,8 +75,7 @@ void ac_buffer_read_le(ac_buffer_t* pBuf, uint8_t* buf, size_t size)
 void ac_buffer_read_n_skip(ac_buffer_t *pBuf, size_t size)
 {
     ENSURE_READ_LENGTH(pBuf, size);
-  while(size > 0)
+    while (size > 0) {
-  {
         size_t cpy = ac_buffer_size(pBuf);
         cpy = MIN(cpy, size);
         pBuf->data += cpy;
@@ -97,8 +88,7 @@ void ac_buffer_read_n_skip(ac_buffer_t* pBuf, size_t size)
 size_t ac_buffer_reader_readable(const ac_buffer_t *pBuf)
 {
     size_t r = 0;
-  while( pBuf != NULL )
+    while (pBuf != NULL) {
-  {
         r += ac_buffer_size(pBuf);
         pBuf = ac_buffer_next(pBuf);
     }
@@ -121,23 +111,19 @@ bool ac_buffer_reader_cmp_bytes(const ac_buffer_t* pBuf, const uint8_t* bytes, s
 {
     ac_buffer_t reader;
 
-  if( length > ac_buffer_reader_readable(pBuf) )
+    if (length > ac_buffer_reader_readable(pBuf)) {
-  {
         return false;
     }
 
     ac_buffer_dup(&reader, pBuf);
 
-  while(length > 0)
+    while (length > 0) {
-  {
         size_t sz = ac_buffer_reader_current_buffer_length(&reader);
-    if( sz > length )
+        if (sz > length) {
-    {
             sz = length;
         }
         int c = memcmp(ac_buffer_reader_current_buffer_pointer(&reader), bytes, sz);
-    if(c)
+        if (c) {
-    {
             return false;
         }
         length -= sz;
@@ -153,8 +139,7 @@ bool ac_buffer_reader_cmp(const ac_buffer_t* pBuf1, const ac_buffer_t* pBuf2)
     ac_buffer_t reader1;
     ac_buffer_t reader2;
 
-  if( ac_buffer_reader_readable(pBuf1) != ac_buffer_reader_readable(pBuf2) )
+    if (ac_buffer_reader_readable(pBuf1) != ac_buffer_reader_readable(pBuf2)) {
-  {
         return false;
     }
 
@@ -162,16 +147,14 @@ bool ac_buffer_reader_cmp(const ac_buffer_t* pBuf1, const ac_buffer_t* pBuf2)
     ac_buffer_dup(&reader2, pBuf2);
 
     size_t length = ac_buffer_reader_readable(pBuf1);
-  while(length > 0)
+    while (length > 0) {
-  {
         size_t sz1 = ac_buffer_reader_current_buffer_length(&reader1);
         size_t sz2 = ac_buffer_reader_current_buffer_length(&reader2);
 
         size_t sz = MIN(sz1, sz2);
 
         int c = memcmp(ac_buffer_reader_current_buffer_pointer(&reader1), ac_buffer_reader_current_buffer_pointer(&reader2), sz);
-    if(c)
+        if (c) {
-    {
             return false;
         }
         length -= sz;

features/nfc/nfc/ISO7816App.h

@@ -44,8 +44,7 @@ namespace nfc {
         /**
          * A Command APDU (Application Protocol Data Unit) .
          */
-            struct CAPDU
+        struct CAPDU {
-            {
             uint8_t cla; ///< CLA - Instruction class
             uint8_t ins; ///< INS - Instruction code
             uint8_t p1; ///< P1 - First parameter
@@ -57,8 +56,7 @@ namespace nfc {
         /**
          * A Response APDU (Application Protocol Data Unit)
          */
-            struct RAPDU
+        struct RAPDU {
-            {
             ac_buffer_t dataOut; ///< Response data
             uint16_t sw; ///< Status word
         };

features/nfc/nfc/NFCDefinitions.h

@@ -24,8 +24,7 @@
 
 namespace mbed {
 namespace nfc {
-    struct nfc_rf_protocols_bitmask_t
+struct nfc_rf_protocols_bitmask_t {
-    {
     uint8_t initiator_t1t : 1;
     uint8_t initiator_t2t : 1;
     uint8_t initiator_t3t : 1;

features/nfc/nfc/NFCNDEFCapable.h

@@ -46,7 +46,10 @@ namespace nfc {
      *
      * @return whether NDEF content is supported
      */
-        virtual bool is_ndef_supported() const { return false; }
+    virtual bool is_ndef_supported() const
+    {
+        return false;
+    }
 
     struct Delegate {
         /**
@@ -64,7 +67,10 @@ namespace nfc {
          * @param[in] capacity the buffer's capacity
          * @return the number of bytes actually used
          */
-            virtual size_t build_ndef_message(uint8_t* buffer, size_t capacity) { return 0; } 
+        virtual size_t build_ndef_message(uint8_t *buffer, size_t capacity)
+        {
+            return 0;
+        }
     };
 
     /**

features/nfc/source/controllers/PN512Driver.cpp

@@ -16,17 +16,18 @@
 
 #include "PN512Driver.h"
 
-PN512Driver::PN512Driver(PN512TransportDriver* transport_driver) : NFCControllerDriver(), _transport_driver(transport_driver) {
+PN512Driver::PN512Driver(PN512TransportDriver *transport_driver) : NFCControllerDriver(), _transport_driver(transport_driver)
+{
     _transport_driver->set_delegate(this);
 }
 
-nfc_transceiver_t* PN512Driver::initialize(nfc_scheduler_timer_t* scheduler_timer) {
+nfc_transceiver_t *PN512Driver::initialize(nfc_scheduler_timer_t *scheduler_timer)
+{
     // Initialize transport
     _transport_driver->initialize();
 
     nfc_err_t ret = pn512_init(&pn512, _transport_driver->get_transport(), scheduler_timer);
-    if( ret != NFC_OK )
+    if (ret != NFC_OK) {
-    {
         NFC_ERR("PN512 init error (%d)", ret);
         return NULL;
     }
@@ -35,7 +36,8 @@ nfc_transceiver_t* PN512Driver::initialize(nfc_scheduler_timer_t* scheduler_time
     return pn512_get_transceiver(&pn512);
 }
 
-void PN512Driver::get_supported_nfc_techs(nfc_tech_t* initiator, nfc_tech_t* target) const {
+void PN512Driver::get_supported_nfc_techs(nfc_tech_t *initiator, nfc_tech_t *target) const
+{
     initiator->nfc_type1 = 0;
     initiator->nfc_type2 = 1;
     initiator->nfc_type3 = 1;
@@ -55,6 +57,7 @@ void PN512Driver::get_supported_nfc_techs(nfc_tech_t* initiator, nfc_tech_t* tar
     target->nfc_nfc_dep_f_424 = 1;
 }
 
-void PN512Driver::on_hw_interrupt() {
+void PN512Driver::on_hw_interrupt()
+{
     hw_interrupt(); // Propagate interrupt signal
 }

features/nfc/source/controllers/PN512SPITransportDriver.cpp

@@ -26,7 +26,8 @@ PN512SPITransportDriver::PN512SPITransportDriver(PinName mosi, PinName miso, Pin
     _spi(mosi, miso, sclk),
     _ssel(ssel, 1),
     _irq(irq, PullNone),
-    _rst(rst, 1) {
+    _rst(rst, 1)
+{
 
     // Use SPI mode 0
     _spi.format(8, 0);
@@ -38,7 +39,8 @@ PN512SPITransportDriver::PN512SPITransportDriver(PinName mosi, PinName miso, Pin
     nfc_transport_init(&_nfc_transport, &PN512SPITransportDriver::s_transport_write, &PN512SPITransportDriver::s_transport_read, this);
 }
 
-void PN512SPITransportDriver::initialize() {
+void PN512SPITransportDriver::initialize()
+{
     // Deactivate IRQ
     _irq.rise(callback(NULL));
 
@@ -53,11 +55,13 @@ void PN512SPITransportDriver::initialize() {
     _irq.rise(callback(this, &PN512SPITransportDriver::hw_interrupt));
 }
 
-nfc_transport_t* PN512SPITransportDriver::get_transport() const {
+nfc_transport_t *PN512SPITransportDriver::get_transport() const
+{
     return &_nfc_transport;
 }
 
-void PN512SPITransportDriver::transport_write( uint8_t address, const uint8_t* outBuf, size_t outLen ) {
+void PN512SPITransportDriver::transport_write(uint8_t address, const uint8_t *outBuf, size_t outLen)
+{
     if (outLen == 0) {
         return;
     }
@@ -70,7 +74,8 @@ void PN512SPITransportDriver::transport_write( uint8_t address, const uint8_t* o
     _ssel = 1;
 }
 
-void PN512SPITransportDriver::transport_read( uint8_t address, uint8_t* inBuf, size_t inLen ) {
+void PN512SPITransportDriver::transport_read(uint8_t address, uint8_t *inBuf, size_t inLen)
+{
     if (inLen == 0) {
         return;
     }
@@ -93,12 +98,14 @@ void PN512SPITransportDriver::transport_read( uint8_t address, uint8_t* inBuf, s
 }
 
 // Callbacks from munfc
-static void PN512SPITransportDriver::s_transport_write( uint8_t address, const uint8_t* outBuf, size_t outLen, void* pUser ) {
+static void PN512SPITransportDriver::s_transport_write(uint8_t address, const uint8_t *outBuf, size_t outLen, void *pUser)
+{
     PN512SPITransportDriver *self = (PN512SPITransportDriver *)pUser;
     self->transport_write(address, outBuf, outLen);
 }
 
-static void PN512SPITransportDriver::s_transport_read( uint8_t address, uint8_t* inBuf, size_t inLen, void* pUser ) {
+static void PN512SPITransportDriver::s_transport_read(uint8_t address, uint8_t *inBuf, size_t inLen, void *pUser)
+{
     PN512SPITransportDriver *self = (PN512SPITransportDriver *)pUser;
     self->transport_read(address, inBuf, inLen);
 }

features/nfc/source/controllers/PN512TransportDriver.cpp

@@ -19,15 +19,18 @@
 using namespace mbed;
 using namespace mbed::nfc;
 
-PN512TransportDriver::PN512TransportDriver() : _delegate(NULL) {
+PN512TransportDriver::PN512TransportDriver() : _delegate(NULL)
+{
 
 }
 
-void PN512TransportDriver::set_delegate(Delegate* delegate) {
+void PN512TransportDriver::set_delegate(Delegate *delegate)
+{
     _delegate = delegate;
 }
 
-void PN512TransportDriver::hw_interrupt() {
+void PN512TransportDriver::hw_interrupt()
+{
     if (_delegate != NULL) {
         _delegate->on_hw_interrupt();
     }

features/nfc/source/nfc/NFCController.cpp

@@ -168,7 +168,8 @@ void NFCController::polling_callback(nfc_err_t ret)
     }
 }
 
-void NFCController::scheduler_process(bool hw_interrupt) {
+void NFCController::scheduler_process(bool hw_interrupt)
+{
     _timer.detach(); // Cancel timeout - if it triggers, it's ok as we'll have an "early" iteration which will likely be a no-op
 
     // Process stack events
@@ -177,13 +178,15 @@ void NFCController::scheduler_process(bool hw_interrupt) {
     _timer.attach(callback(this, &NFCController::on_timeout));
 }
 
-void NFCController::on_hw_interrupt() {
+void NFCController::on_hw_interrupt()
+{
     // Run scheduler - this is called in interrupt context
     _timer.detach(); // Cancel timeout - if it triggers anyways, it's ok
     _queue->call(this, NFCController::scheduler_process, true);
 }
 
-void NFCController::on_timeout() {
+void NFCController::on_timeout()
+{
     // Run scheduler - this is called in interrupt context
     _queue->call(this, NFCController::scheduler_process, false);
 }
@@ -195,26 +198,31 @@ static void NFCController::s_polling_callback(nfc_transceiver_t* pTransceiver, n
 }
 
 // Implementation nfc_scheduler_timer_t
-void nfc_scheduler_timer_init(nfc_scheduler_timer_t* timer) {
+void nfc_scheduler_timer_init(nfc_scheduler_timer_t *timer)
+{
     (void)timer; // This is a no-op
 }
 
-void nfc_scheduler_timer_start(nfc_scheduler_timer_t* timer) {
+void nfc_scheduler_timer_start(nfc_scheduler_timer_t *timer)
+{
     Timer *mbed_timer = (Timer *)timer;
     mbed_timer->start();
 }
 
-uint32_t nfc_scheduler_timer_get(nfc_scheduler_timer_t* timer) {
+uint32_t nfc_scheduler_timer_get(nfc_scheduler_timer_t *timer)
+{
     Timer *mbed_timer = (Timer *)timer;
     return (uint32_t)mbed_timer->read_ms();
 }
 
-void nfc_scheduler_timer_stop(nfc_scheduler_timer_t* timer) {
+void nfc_scheduler_timer_stop(nfc_scheduler_timer_t *timer)
+{
     Timer *mbed_timer = (Timer *)timer;
     mbed_timer->stop();
 }
 
-void nfc_scheduler_timer_reset(nfc_scheduler_timer_t* timer) {
+void nfc_scheduler_timer_reset(nfc_scheduler_timer_t *timer)
+{
     Timer *mbed_timer = (Timer *)timer;
     mbed_timer->reset();
 }

features/nfc/source/nfc/NFCControllerDriver.cpp

@@ -19,15 +19,18 @@
 using namespace mbed;
 using namespace mbed::nfc;
 
-NFCControllerDriver::NFCControllerDriver() : _delegate(NULL) {
+NFCControllerDriver::NFCControllerDriver() : _delegate(NULL)
+{
 
 }
 
-void NFCControllerDriver::set_delegate(Delegate* delegate) {
+void NFCControllerDriver::set_delegate(Delegate *delegate)
+{
     _delegate = delegate;
 }
 
-void NFCControllerDriver::hw_interrupt() {
+void NFCControllerDriver::hw_interrupt()
+{
     if (_delegate != NULL) {
         _delegate->on_hw_interrupt();
     }

features/nfc/source/nfc/NFCEEPROM.cpp

@@ -26,7 +26,8 @@ NFCEEPROM(NFCEEPROMDriver* driver, events::EventQueue* queue, uint8_t* ndef_buff
     _driver->set_delegate(this);
 }
 
-nfc_err_t NFCEEPROM::initialize() {
+nfc_err_t NFCEEPROM::initialize()
+{
     MBED_ASSERT(_initialized == false); // Initialize should only be called once
 
     // Initialize driver
@@ -34,11 +35,13 @@ nfc_err_t NFCEEPROM::initialize() {
     _initialized = true;
 }
 
-void NFCEEPROM::set_delegate(NFCEEPROM::Delegate* delegate) {
+void NFCEEPROM::set_delegate(NFCEEPROM::Delegate *delegate)
+{
     _delegate = delegate;
 }
 
-void NFCEEPROM::write_ndef_message() {
+void NFCEEPROM::write_ndef_message()
+{
     MBED_ASSERT(_initialized == true);
     if (_current_op != nfc_eeprom_idle) {
         if (_delegate != NULL) {
@@ -73,7 +76,8 @@ void NFCEEPROM::write_ndef_message() {
                       // 4 - End session
 }
 
-void NFCEEPROM::read_ndef_message() {
+void NFCEEPROM::read_ndef_message()
+{
     MBED_ASSERT(_initialized == true);
     if (_current_op != nfc_eeprom_idle) {
         if (_delegate != NULL) {
@@ -96,7 +100,8 @@ void NFCEEPROM::read_ndef_message() {
     // 4 - End session
 }
 
-void NFCEEPROM::erase_ndef_message() {
+void NFCEEPROM::erase_ndef_message()
+{
     // We don't want to take any risks, so erase the whole address space
     // And set the message size to 0
 
@@ -122,7 +127,8 @@ void NFCEEPROM::erase_ndef_message() {
     // 4 - End session
 }
 
-void NFCEEPROM::on_session_started(bool success) {
+void NFCEEPROM::on_session_started(bool success)
+{
     switch (_current_op) {
         case nfc_eeprom_write_start_session:
             if (!success) {
@@ -158,7 +164,8 @@ void NFCEEPROM::on_session_started(bool success) {
     }
 }
 
-void NFCEEPROM::on_session_ended(bool success) {
+void NFCEEPROM::on_session_ended(bool success)
+{
     switch (_current_op) {
         case nfc_eeprom_write_end_session:
             if (!success) {
@@ -204,7 +211,8 @@ void NFCEEPROM::on_session_ended(bool success) {
     }
 }
 
-void NFCEEPROM::on_bytes_read(size_t count) {
+void NFCEEPROM::on_bytes_read(size_t count)
+{
     switch (_current_op) {
         case nfc_eeprom_read_read_bytes:
             if (count == 0) {
@@ -227,7 +235,8 @@ void NFCEEPROM::on_bytes_read(size_t count) {
     }
 }
 
-void NFCEEPROM::on_bytes_written(size_t count) {
+void NFCEEPROM::on_bytes_written(size_t count)
+{
     switch (_current_op) {
         case nfc_eeprom_write_write_bytes:
             if (count == 0) {
@@ -249,7 +258,8 @@ void NFCEEPROM::on_bytes_written(size_t count) {
     }
 }
 
-void NFCEEPROM::on_size_written(bool success) {
+void NFCEEPROM::on_size_written(bool success)
+{
     switch (_current_op) {
         case nfc_eeprom_write_write_size:
             if (!success) {
@@ -280,7 +290,8 @@ void NFCEEPROM::on_size_written(bool success) {
     }
 }
 
-void NFCEEPROM::on_size_read(bool success, size_t size) {
+void NFCEEPROM::on_size_read(bool success, size_t size)
+{
     switch (_current_op) {
         case nfc_eeprom_read_read_size:
             if (!success) {
@@ -293,8 +304,7 @@ void NFCEEPROM::on_size_read(bool success, size_t size) {
             ac_buffer_builder_reset(buffer_builder);
 
             // Check that we have a big enough buffer to read the message
-            if( size > ac_buffer_builder_writable(buffer_builder) )
+            if (size > ac_buffer_builder_writable(buffer_builder)) {
-            {
                 // Not enough space, close session
                 _current_op = nfc_eeprom_read_end_session;
                 _operation_result = NFC_ERR_BUFFER_TOO_SMALL;
@@ -317,7 +327,8 @@ void NFCEEPROM::on_size_read(bool success, size_t size) {
     }
 }
 
-void NFCEEPROM::on_bytes_erased(size_t count) {
+void NFCEEPROM::on_bytes_erased(size_t count)
+{
     switch (_current_op) {
         case nfc_eeprom_erase_erase_bytes:
             if (count == 0) {
@@ -338,49 +349,51 @@ void NFCEEPROM::on_bytes_erased(size_t count) {
     }
 }
 
-void NFCEEPROM::on_event() {
+void NFCEEPROM::on_event()
+{
     // Just schedule a task on event queue
     _queue->call(_driver, NFCEEPROMDriver::process_events);
 }
 
-void NFCEEPROM::continue_write() {
+void NFCEEPROM::continue_write()
+{
     if (ac_buffer_reader_readable(&_ndef_buffer_reader) > 0) {
         // Continue writing
         _driver->write_bytes(_eeprom_address, ac_buffer_reader_current_buffer_pointer(&_ndef_buffer_reader), ac_buffer_reader_current_buffer_length(&_ndef_buffer_reader));
-    }
+    } else {
-    else {
         // Now update size
         _current_op = nfc_eeprom_write_write_size;
         _driver->write_size(_eeprom_address);
     }
 }
 
-void NFCEEPROM::continue_erase() {
+void NFCEEPROM::continue_erase()
+{
     if (_eeprom_address < _driver->get_max_size()) {
         // Continue erasing
         _driver->erase_bytes(_eeprom_address, _driver->get_max_size() - _eeprom_address);
-    }
+    } else {
-    else {
         // Now update size
         _current_op = nfc_eeprom_erase_write_size;
         _driver->write_size(0);
     }
 }
 
-void NFCEEPROM::continue_read() {
+void NFCEEPROM::continue_read()
+{
     if (_eeprom_address < _ndef_buffer_read_sz) {
         // Continue reading
         ac_buffer_builder_t *buffer_builder = ndef_msg_buffer_builder(ndef_message());
         _driver->read_bytes(_eeprom_address, ac_buffer_builder_write_position(buffer_builder), _ndef_buffer_read_sz - _eeprom_address);
-    }
+    } else {
-    else {
         // Done, close session
         _operation_result = NFC_OK;
         _driver->end_session();
     }
 }
 
-void NFCEEPROM::handle_error(nfc_err_t ret) {
+void NFCEEPROM::handle_error(nfc_err_t ret)
+{
     // Save & reset current op
     nfc_eeprom_operation_t last_op = _current_op;
     _current_op = nfc_eeprom_idle;
@@ -388,11 +401,9 @@ void NFCEEPROM::handle_error(nfc_err_t ret) {
     if (_delegate != NULL) {
         if (last_op <= nfc_eeprom_write_end_session) {
             _delegate->on_ndef_message_written(ret);
-        }
+        } else if (last_op <= nfc_eeprom_read_end_session) {
-        else if(last_op <= nfc_eeprom_read_end_session) {
             _delegate->on_ndef_message_read(ret);
-        }
+        } else if (last_op <= nfc_eeprom_erase_end_session) {
-        else if(last_op <= nfc_eeprom_erase_end_session) {
             _delegate->on_ndef_message_erased(ret);
         }
     }

features/nfc/source/nfc/NFCEEPROMDriver.cpp

@@ -19,10 +19,12 @@
 using namespace mbed;
 using namespace mbed::nfc;
 
-NFCEEPROMDriver::NFCEEPROMDriver() : _delegate(NULL) {
+NFCEEPROMDriver::NFCEEPROMDriver() : _delegate(NULL)
+{
 
 }
 
-void NFCEEPROMDriver::set_delegate(Delegate* delegate) {
+void NFCEEPROMDriver::set_delegate(Delegate *delegate)
+{
     _delegate = delegate;
 }

features/nfc/source/nfc/NFCNDEFCapable.cpp

@@ -52,22 +52,26 @@ void NFCNDEFCapable::build_ndef_message(ac_buffer_builder_t& buffer_builder)
     }
 }
 
-nfc_err_t NFCNDEFCapable::s_ndef_encode(ndef_msg_t* pTag, buffer_builder_t* pBufferBldr, void* pUserData) {
+nfc_err_t NFCNDEFCapable::s_ndef_encode(ndef_msg_t *pTag, buffer_builder_t *pBufferBldr, void *pUserData)
+{
     NFCNDEFCapable *self = (NFCNDEFCapable *)pUserData;
     self->ndef_encode(pBufferBldr);
 }
 
-nfc_err_t NFCNDEFCapable::s_ndef_decode(ndef_msg_t* pTag, buffer_t* pBuffer, void* pUserData) {
+nfc_err_t NFCNDEFCapable::s_ndef_decode(ndef_msg_t *pTag, buffer_t *pBuffer, void *pUserData)
+{
     NFCNDEFCapable *self = (NFCNDEFCapable *)pUserData;
     self->ndef_decode(pBuffer);
 }
 
-nfc_err_t NFCNDEFCapable::ndef_encode(buffer_builder_t* pBufferBldr) {
+nfc_err_t NFCNDEFCapable::ndef_encode(buffer_builder_t *pBufferBldr)
+{
     build_ndef_message(buffer_builder);
     return NFC_OK;
 }
 
-nfc_err_t NFCNDEFCapable::ndef_decode(buffer_t* pBuffer) {
+nfc_err_t NFCNDEFCapable::ndef_decode(buffer_t *pBuffer)
+{
     parse_ndef_message(pBuffer);
     return NFC_OK;
 }

features/nfc/source/nfc/NFCRemoteEndpoint.cpp

@@ -25,19 +25,21 @@
 using namespace mbed;
 using namespace mbed::nfc;
 
-NFCRemoteEndpoint::NFCRemoteEndpoint(NFCController* controller) : _controller(controller), _is_lost(false) {
+NFCRemoteEndpoint::NFCRemoteEndpoint(NFCController *controller) : _controller(controller), _is_lost(false)
+{
 
 }
 
-bool NFCRemoteEndpoint::is_lost() const {
+bool NFCRemoteEndpoint::is_lost() const
+{
     return _is_lost;
 }
 
-nfc_rf_protocols_bitmask_t NFCRemoteEndpoint::rf_protocols() {
+nfc_rf_protocols_bitmask_t NFCRemoteEndpoint::rf_protocols()
+{
     nfc_rf_protocols_bitmask_t rf_protocols = {0};
     nfc_tech_t active_tech = transceiver_get_active_techs(_transceiver);
-    if(!transceiver_is_initiator_mode(_transceiver))
+    if (!transceiver_is_initiator_mode(_transceiver)) {
-    {
         // Note: We only support ISO-DEP for now
         rf_protocols.target_iso_dep = active_tech.nfc_iso_dep_a || active_tech.nfc_iso_dep_b;
     }
@@ -45,11 +47,13 @@ nfc_rf_protocols_bitmask_t NFCRemoteEndpoint::rf_protocols() {
     return rf_protocols;
 }
 
-void NFCRemoteEndpoint::set_lost() {
+void NFCRemoteEndpoint::set_lost()
+{
     _is_lost = true;
 }
 
-NFCController* NFCRemoteEndpoint::nfc_controller() const {
+NFCController *NFCRemoteEndpoint::nfc_controller() const
+{
     return _controller;
 }
 

features/nfc/source/nfc/NFCRemoteInitiator.cpp

@@ -20,11 +20,13 @@ using namespace mbed;
 using namespace mbed::nfc;
 
 NFCRemoteInitiator::NFCRemoteInitiator(NFCController *controller, uint8_t *buffer, size_t buffer_size) :
-    NFCRemoteEndpoint(controller), NFCNDEFCapable(buffer, buffer_size) {
+    NFCRemoteEndpoint(controller), NFCNDEFCapable(buffer, buffer_size)
+{
 
 }
 
-NFCRemoteInitiator::~NFCRemoteInitiator() {
+NFCRemoteInitiator::~NFCRemoteInitiator()
+{
 
 }
 

features/nfc/source/nfc/NFCTarget.cpp

@@ -20,10 +20,12 @@ using namespace mbed;
 using namespace mbed::nfc;
 
 NFCTarget::NFCTarget(uint8_t *buffer, size_t buffer_size) :
-    NFCNDEFCapable(buffer, buffer_size) {
+    NFCNDEFCapable(buffer, buffer_size)
+{
 
 }
 
-NFCTarget::~NFCTarget() {
+NFCTarget::~NFCTarget()
+{
 
 }

features/nfc/source/nfc/Type4RemoteInitiator.cpp

@@ -30,7 +30,8 @@ using namespace mbed::nfc;
 
 Type4RemoteInitiator::Type4RemoteInitiator(NFCController *controller, uint8_t *buffer, size_t buffer_size) :
     NFCRemoteInitiator(ndef_buffer, ndef_buffer_sz),
-    _controller(controller), _is_connected(false) , _is_disconnected(false), _apps(NULL) {
+    _controller(controller), _is_connected(false), _is_disconnected(false), _apps(NULL)
+{
     // Init ISO7816
     nfc_tech_iso7816_init(&_iso7816, _controller->transceiver(), &Type4RemoteInitiator::s_disconnected_callback, this);
 
@@ -38,7 +39,8 @@ Type4RemoteInitiator::Type4RemoteInitiator(NFCController* controller, uint8_t* b
     nfc_tech_type4_target_init(&_type4, &_iso7816, ndef_message());
 }
 
-nfc_err_t Type4RemoteInitiator::connect() {
+nfc_err_t Type4RemoteInitiator::connect()
+{
     if (_is_connected) {
         return NFC_BUSY;
     }
@@ -54,7 +56,8 @@ nfc_err_t Type4RemoteInitiator::connect() {
     connected();
 }
 
-nfc_err_t Type4RemoteInitiator::disconnect() {
+nfc_err_t Type4RemoteInitiator::disconnect()
+{
     if (!_is_connected) {
         return NFC_OK;
     }
@@ -67,19 +70,21 @@ nfc_err_t Type4RemoteInitiator::disconnect() {
     nfc_tech_iso7816_disconnect(&_iso7816);
 }
 
-bool Type4RemoteInitiator::is_connected() const {
+bool Type4RemoteInitiator::is_connected() const
+{
     return _is_connected;
 }
 
-bool Type4RemoteInitiator::is_disconnected() const {
+bool Type4RemoteInitiator::is_disconnected() const
+{
     return _is_disconnected;
 }
 
-nfc_rf_protocols_bitmask_t Type4RemoteInitiator::rf_protocols() {
+nfc_rf_protocols_bitmask_t Type4RemoteInitiator::rf_protocols()
+{
     nfc_rf_protocols_bitmask_t rf_protocols = {0};
     nfc_tech_t active_tech = transceiver_get_active_techs(_transceiver);
-    if(!transceiver_is_initiator_mode(_transceiver))
+    if (!transceiver_is_initiator_mode(_transceiver)) {
-    {
         // We only support ISO-DEP
         rf_protocols.target_iso_dep = active_tech.nfc_iso_dep_a || active_tech.nfc_iso_dep_b;
     }
@@ -87,24 +92,27 @@ nfc_rf_protocols_bitmask_t Type4RemoteInitiator::rf_protocols() {
     return rf_protocols;
 }
 
-virtual nfc_tag_type_t Type4RemoteInitiator::nfc_tag_type() const {
+virtual nfc_tag_type_t Type4RemoteInitiator::nfc_tag_type() const
+{
     nfc_tech_t active_tech = transceiver_get_active_techs(_transceiver);
     if (active_tech.nfc_iso_dep_a) {
         return nfc_tag_type_4a;
-    }
+    } else { // if(active_tech.nfc_iso_dep_b)
-    else { // if(active_tech.nfc_iso_dep_b)
         return nfc_tag_type_4b;
     }
 }
 
-virtual bool Type4RemoteInitiator::is_iso7816_supported() const {
+virtual bool Type4RemoteInitiator::is_iso7816_supported() const
+{
     return true;
 }
 
-virtual void Type4RemoteInitiator::add_iso7816_application(ISO7816App* application) {
+virtual void Type4RemoteInitiator::add_iso7816_application(ISO7816App *application)
+{
     nfc_tech_iso7816_add_app(&_iso7816, application->_iso7816_app);
 }
 
-virtual bool Type4RemoteInitiator::is_ndef_supported() const {
+virtual bool Type4RemoteInitiator::is_ndef_supported() const
+{
     return true;
 }

features/nfc/stack/ndef/ndef.h

@@ -51,8 +51,7 @@ typedef nfc_err_t (*ndef_encode_fn_t)(ndef_msg_t* pTag, buffer_builder_t* pBuffe
  */
 typedef nfc_err_t (*ndef_decode_fn_t)(ndef_msg_t *pTag, buffer_t *pBuffer, void *pUserData);
 
-typedef struct __ndef_msg
+typedef struct __ndef_msg {
-{
     ndef_encode_fn_t encode;
     ndef_decode_fn_t decode;
     buffer_builder_t bufferBldr;
@@ -63,8 +62,7 @@ void ndef_msg_init( ndef_msg_t* pNdef, ndef_encode_fn_t encode, ndef_decode_fn_t
 
 static inline nfc_err_t ndef_msg_encode(ndef_msg_t *pNdef)
 {
-  if(pNdef->encode == NULL)
+    if (pNdef->encode == NULL) {
-  {
         return NFC_OK;
     }
     return pNdef->encode(pNdef, &pNdef->bufferBldr, pNdef->pUserData);
@@ -72,8 +70,7 @@ static inline nfc_err_t ndef_msg_encode(ndef_msg_t* pNdef)
 
 static inline nfc_err_t ndef_msg_decode(ndef_msg_t *pNdef)
 {
-  if(pNdef->decode == NULL)
+    if (pNdef->decode == NULL) {
-  {
         return NFC_OK;
     }
     return pNdef->decode(pNdef, buffer_builder_buffer(&pNdef->bufferBldr), pNdef->pUserData);

features/nfc/stack/platform/nfc_debug.h

@@ -21,7 +21,8 @@
 #if NFC_DEBUG && !defined(NDEBUG)
 #include "stdio.h"
 #include "stdarg.h"
-static inline void nfc_dbg_print(const char* type, const char* module, unsigned int line, const char* fmt, ...) {
+static inline void nfc_dbg_print(const char *type, const char *module, unsigned int line, const char *fmt, ...)
+{
 #if !defined(NDEBUG)
     printf("NFC [%s] %s:%u ", type, module, line);
     va_list args;

features/nfc/stack/platform/nfc_scheduler.c

@@ -41,8 +41,7 @@ void nfc_scheduler_init(nfc_scheduler_t* pScheduler, nfc_scheduler_timer_t* pTim
 uint32_t nfc_scheduler_iteration(nfc_scheduler_t *pScheduler, uint32_t events)
 {
     bool triggered = false;
-  while(true)
+    while (true) {
-  {
         nfc_task_t *pPrioTask = NULL;
         nfc_task_t *pPrioTaskPrevious = NULL;
         uint32_t prioTaskEvent = 0;
@@ -50,8 +49,7 @@ uint32_t nfc_scheduler_iteration(nfc_scheduler_t* pScheduler, uint32_t events)
         nfc_task_t *pPreviousTask = NULL;
         nfc_task_t *pTask = pScheduler->pNext;
 
-    if( pTask == NULL )
+        if (pTask == NULL) {
-    {
             NFC_DBG("Empty queue, %lu ms elapsed", nfc_scheduler_timer_get(pScheduler->pTimer));
             //Empty queue, return
             return MAX_TIMEOUT;
@@ -62,11 +60,9 @@ uint32_t nfc_scheduler_iteration(nfc_scheduler_t* pScheduler, uint32_t events)
         NFC_DBG("%lu ms elapsed", timeElapsed);
         nfc_scheduler_timer_reset(pScheduler->pTimer);
 
-    do
+        do {
-    {
             //Apply timeouts
-      if( pTask->events & EVENT_TIMEOUT )
+            if (pTask->events & EVENT_TIMEOUT) {
-      {
                 pTask->timeout -= timeElapsed;
             }
             pPreviousTask = pTask;
@@ -76,11 +72,9 @@ uint32_t nfc_scheduler_iteration(nfc_scheduler_t* pScheduler, uint32_t events)
         pTask = pScheduler->pNext;
         pPreviousTask = NULL;
         timeout = MAX_TIMEOUT;
-    do
+        do {
-    {
             //Check which task should be woken up first
-      if( (events & EVENT_HW_INTERRUPT) && (pTask->events & EVENT_HW_INTERRUPT) )
+            if ((events & EVENT_HW_INTERRUPT) && (pTask->events & EVENT_HW_INTERRUPT)) {
-      {
                 //Hardware interrupts have prio
                 pPrioTask = pTask;
                 pPrioTaskPrevious = pPreviousTask;
@@ -88,9 +82,7 @@ uint32_t nfc_scheduler_iteration(nfc_scheduler_t* pScheduler, uint32_t events)
                 events &= ~EVENT_HW_INTERRUPT; //Only one task gets triggered per event
                 prioTaskEvent = EVENT_HW_INTERRUPT;
                 break;
-      }
+            } else if ((pTask->events & EVENT_TIMEOUT) && (pTask->timeout < timeout)) {
-      else if( (pTask->events & EVENT_TIMEOUT) && (pTask->timeout < timeout) )
-      {
                 pPrioTask = pTask;
                 pPrioTaskPrevious = pPreviousTask;
                 timeout = pTask->timeout;
@@ -100,35 +92,27 @@ uint32_t nfc_scheduler_iteration(nfc_scheduler_t* pScheduler, uint32_t events)
             pTask = pTask->pNext;
         } while (pTask != NULL);
 
-    if( pPrioTask == NULL )
+        if (pPrioTask == NULL) {
-    {
             //No task to wake up, exit
             NFC_DBG("No task to wake up");
             return MAX_TIMEOUT;
         }
 
-    if( timeout >  0 )
+        if (timeout >  0) {
-    {
             //No task to wake up yet
-      if( timeout > MAX_TIMEOUT )
+            if (timeout > MAX_TIMEOUT) {
-      {
                 NFC_DBG("No task to wake up");
                 return MAX_TIMEOUT;
-      }
+            } else {
-      else
-      {
                 NFC_DBG("No task to wake up, wait %lu ms", timeout);
                 return timeout;
             }
         }
 
         //Dequeue task
-    if( pPrioTaskPrevious == NULL )
+        if (pPrioTaskPrevious == NULL) {
-    {
             pScheduler->pNext = pPrioTask->pNext;
-    }
+        } else {
-    else
-    {
             pPrioTaskPrevious->pNext = pPrioTask->pNext;
         }
         pPrioTask->pNext = NULL;
@@ -149,13 +133,11 @@ void nfc_scheduler_queue_task(nfc_scheduler_t* pScheduler, nfc_task_t* pTask)
     //Find last task
     nfc_task_t *pPrevTask = pScheduler->pNext;
     pTask->pNext = NULL;
-  if( pPrevTask == NULL )
+    if (pPrevTask == NULL) {
-  {
         pScheduler->pNext = pTask;
         return;
     }
-  while( pPrevTask->pNext != NULL )
+    while (pPrevTask->pNext != NULL) {
-  {
         pPrevTask = pPrevTask->pNext;
     }
     pPrevTask->pNext = pTask;
@@ -166,27 +148,21 @@ void nfc_scheduler_dequeue_task(nfc_scheduler_t* pScheduler, bool abort, nfc_tas
     NFC_DBG("Dequeuing task %p", pTask);
     //Find task
     nfc_task_t *pPrevTask = pScheduler->pNext;
-  if( pPrevTask == NULL )
+    if (pPrevTask == NULL) {
-  {
         pTask->pNext = NULL;
         return;
     }
-  if( pPrevTask == pTask )
+    if (pPrevTask == pTask) {
-  {
+        if (abort) {
-    if(abort)
-    {
             pTask->fn(EVENT_ABORTED, pTask->pUserData);
         }
         pScheduler->pNext = pTask->pNext;
         pTask->pNext = NULL;
         return;
     }
-  while( pPrevTask->pNext != NULL )
+    while (pPrevTask->pNext != NULL) {
-  {
+        if (pPrevTask->pNext == pTask) {
-    if(pPrevTask->pNext == pTask)
+            if (abort) {
-    {
-      if(abort)
-      {
                 pTask->fn(EVENT_ABORTED, pTask->pUserData);
             }
             pPrevTask->pNext = pTask->pNext;

features/nfc/stack/platform/nfc_scheduler.h

@@ -45,16 +45,14 @@ typedef struct __nfc_timer nfc_scheduler_timer_t;
 struct __nfc_task;
 typedef struct __nfc_task nfc_task_t;
 
-typedef struct __scheduler
+typedef struct __scheduler {
-{
     nfc_task_t *pNext;
     nfc_scheduler_timer_t *pTimer;
 } nfc_scheduler_t;
 
 typedef void (*nfc_task_fn)(uint32_t events, void *pUserData);
 
-struct __nfc_task
+struct __nfc_task {
-{
     uint32_t events;
     int64_t timeout; //millisecs
     int64_t timeoutInitial;

features/nfc/stack/platform/nfc_transport.h

@@ -51,8 +51,7 @@ typedef void (*nfc_transport_write_fn_t)( uint8_t address, const uint8_t* outBuf
  */
 typedef void (*nfc_transport_read_fn_t)(uint8_t address, uint8_t *inBuf, size_t inLen, void *pUser);
 
-typedef struct __transport
+typedef struct __transport {
-{
     nfc_transport_write_fn_t write;
     nfc_transport_read_fn_t read;
     void *pUser;

features/nfc/stack/tech/iso7816/iso7816.c

@@ -83,8 +83,7 @@ void nfc_tech_iso7816_disconnect(nfc_tech_iso7816_t* pIso7816)
 void nfc_tech_iso7816_add_app(nfc_tech_iso7816_t *pIso7816, nfc_tech_iso7816_app_t *pIso7816App)
 {
     nfc_tech_iso7816_app_t **ppPrevApp = &pIso7816->pAppList;
-  while( *ppPrevApp != NULL )
+    while (*ppPrevApp != NULL) {
-  {
         ppPrevApp = &((*ppPrevApp)->pNext);
     }
     *ppPrevApp = pIso7816App;
@@ -105,8 +104,7 @@ nfc_err_t nfc_tech_iso7816_reply(nfc_tech_iso7816_t* pIso7816)
     DBG_BLOCK(buffer_dump(&pIso7816->rApdu.dataOut);)
 
     ret = iso7816_transmit(pIso7816);
-  if(ret)
+    if (ret) {
-  {
         return ret;
     }
 
@@ -116,8 +114,7 @@ nfc_err_t nfc_tech_iso7816_reply(nfc_tech_iso7816_t* pIso7816)
 void iso7816_disconnected(nfc_tech_iso7816_t *pIso7816, bool deselected)
 {
     pIso7816->disconnected = true;
-  if(pIso7816->pSelectedApp != NULL)
+    if (pIso7816->pSelectedApp != NULL) {
-  {
         //Deselect previous app
         pIso7816->pSelectedApp->deselected(pIso7816->pSelectedApp, pIso7816->pSelectedApp->pUserData);
         pIso7816->pSelectedApp = NULL;
@@ -133,8 +130,7 @@ nfc_err_t iso7816_parse(nfc_tech_iso7816_t* pIso7816)
 
     DBG_BLOCK(buffer_dump(buffer_builder_buffer(&pIso7816->rxBldr));)
 
-  if( buffer_reader_readable( buffer_builder_buffer(&pIso7816->rxBldr) ) < 4 )
+    if (buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) < 4) {
-  {
         NFC_ERR("C-APDU is too small");
         pIso7816->rApdu.sw = ISO7816_SW_INVALID_CLASS;
         nfc_tech_iso7816_reply(pIso7816);
@@ -148,46 +144,38 @@ nfc_err_t iso7816_parse(nfc_tech_iso7816_t* pIso7816)
     buffer_init(&pIso7816->cApdu.dataIn, NULL, 0);
     pIso7816->cApdu.maxRespLength = 0;
 
-  if( buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) > 1 )
+    if (buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) > 1) {
-  {
         size_t lc = buffer_read_nu8(buffer_builder_buffer(&pIso7816->rxBldr));
-    if( buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) >= lc )
+        if (buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) >= lc) {
-    {
             buffer_split(&pIso7816->cApdu.dataIn, buffer_builder_buffer(&pIso7816->rxBldr), buffer_builder_buffer(&pIso7816->rxBldr), lc);
-    }
+        } else {
-    else
-    {
             pIso7816->rApdu.sw = ISO7816_SW_WRONG_LENGTH;
             nfc_tech_iso7816_reply(pIso7816);
             return NFC_ERR_LENGTH; //Not a valid frame
         }
     }
 
-  if( buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) >= 1 )
+    if (buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) >= 1) {
-  {
         pIso7816->cApdu.maxRespLength = buffer_read_nu8(buffer_builder_buffer(&pIso7816->rxBldr));
     }
 
     NFC_DBG("C-APDU: CLA:%02X INS:%02X P1:%02X P2:%02X LC:%02X LE:%02X", pIso7816->cApdu.cla, pIso7816->cApdu.ins, pIso7816->cApdu.p1, pIso7816->cApdu.p2,
             buffer_reader_readable(&pIso7816->cApdu.dataIn), pIso7816->cApdu.maxRespLength);
 
-  if( buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) > 0 )
+    if (buffer_reader_readable(buffer_builder_buffer(&pIso7816->rxBldr)) > 0) {
-  {
         pIso7816->rApdu.sw = ISO7816_SW_WRONG_LENGTH;
         nfc_tech_iso7816_reply(pIso7816);
         return NFC_ERR_LENGTH; //Not a valid frame
     }
 
     //See if can select an app
-  if( iso7816_mf_command(pIso7816) )
+    if (iso7816_mf_command(pIso7816)) {
-  {
         nfc_tech_iso7816_reply(pIso7816);
         return NFC_OK;
     }
 
     //Pass command to selected app
-  if( pIso7816->pSelectedApp == NULL )
+    if (pIso7816->pSelectedApp == NULL) {
-  {
         pIso7816->rApdu.sw = ISO7816_SW_NOT_FOUND;
         nfc_tech_iso7816_reply(pIso7816);
         return NFC_ERR_NOT_FOUND; //Not a valid frame
@@ -223,25 +211,18 @@ nfc_err_t iso7816_transmit(nfc_tech_iso7816_t* pIso7816)
 bool iso7816_mf_command(nfc_tech_iso7816_t *pIso7816)
 {
     nfc_tech_iso7816_app_t *pApp;
-  if(pIso7816->cApdu.cla != 0x00)
+    if (pIso7816->cApdu.cla != 0x00) {
-  {
         return false;
     }
-  switch(pIso7816->cApdu.ins)
+    switch (pIso7816->cApdu.ins) {
-  {
         case ISO7816_INS_SELECT:
-    switch(pIso7816->cApdu.p1)
+            switch (pIso7816->cApdu.p1) {
-    {
                 case 0x04: //Selection by DF name
                     pApp = pIso7816->pAppList;
-      while(pApp != NULL)
+                    while (pApp != NULL) {
-      {
+                        if (buffer_reader_readable(&pIso7816->cApdu.dataIn) <= pApp->aidSize) {
-        if( buffer_reader_readable(&pIso7816->cApdu.dataIn) <= pApp->aidSize )
+                            if (buffer_reader_cmp_bytes(&pIso7816->cApdu.dataIn, pApp->aid, buffer_reader_readable(&pIso7816->cApdu.dataIn))) {
-        {
+                                if (pIso7816->pSelectedApp != NULL) {
-          if( buffer_reader_cmp_bytes(&pIso7816->cApdu.dataIn, pApp->aid, buffer_reader_readable(&pIso7816->cApdu.dataIn)) )
-          {
-            if(pIso7816->pSelectedApp != NULL)
-            {
                                     //Deselect previous app
                                     pIso7816->pSelectedApp->deselected(pIso7816->pSelectedApp, pIso7816->pSelectedApp->pUserData);
                                 }
@@ -256,25 +237,19 @@ bool iso7816_mf_command(nfc_tech_iso7816_t* pIso7816)
                     pIso7816->rApdu.sw = ISO7816_SW_NOT_FOUND;
                     return true;
                 default:
-      if(pIso7816->pSelectedApp == NULL)
+                    if (pIso7816->pSelectedApp == NULL) {
-      {
                         pIso7816->rApdu.sw = ISO7816_SW_NOT_FOUND;
                         return true;
-      }
+                    } else {
-      else
-      {
                         return false;
                     }
             }
             break;
         default:
-    if(pIso7816->pSelectedApp == NULL)
+            if (pIso7816->pSelectedApp == NULL) {
-    {
                 pIso7816->rApdu.sw = ISO7816_SW_INVALID_INS;
                 return true;
-    }
+            } else {
-    else
-    {
                 return false;
             }
             break;
@@ -287,16 +262,14 @@ void iso_dep_received_cb(nfc_tech_isodep_t* pIsodep, nfc_err_t ret, void* pUserD
 
     (void) pIsodep;
 
-  if( ret )
+    if (ret) {
-  {
         NFC_WARN("Got error %d", ret);
         return;
     }
 
     //Parse received APDU
     ret = iso7816_parse(pIso7816);
-  if( ret )
+    if (ret) {
-  {
         NFC_WARN("Got error %d", ret);
         return;
     }
@@ -308,8 +281,7 @@ void iso_dep_transmitted_cb(nfc_tech_isodep_t* pIsodep, nfc_err_t ret, void* pUs
 
     (void) pIsodep;
 
-  if( ret )
+    if (ret) {
-  {
         NFC_WARN("Got error %d", ret);
         return;
     }
@@ -340,9 +312,7 @@ void iso_dep_stream_transmit_cb(buffer_t* pDataIn, bool* pClose, size_t maxLengt
     {
         maxLength = buffer_reader_readable(&pIso7816->rApdu.dataOut);
         *pClose = true;
-  }
+    } else {
-  else
-  {
         *pClose = false;
     }
 
@@ -355,8 +325,7 @@ void iso_dep_stream_receive_cb(buffer_t* pDataOut, bool closed, void* pUserParam
 
     (void) closed;
 
-  if( buffer_reader_readable(pDataOut) > buffer_builder_writeable(&pIso7816->rxBldr) )
+    if (buffer_reader_readable(pDataOut) > buffer_builder_writeable(&pIso7816->rxBldr)) {
-  {
         NFC_ERR("Frame will not fit (%d > %d)", buffer_reader_readable(pDataOut), buffer_builder_writeable(&pIso7816->rxBldr));
     }
 

features/nfc/stack/tech/iso7816/iso7816.h

@@ -32,8 +32,7 @@ extern "C" {
 
 #include "tech/isodep/isodep_target.h"
 
-struct nfc_tech_iso7816_c_apdu
+struct nfc_tech_iso7816_c_apdu {
-{
     uint8_t cla;
     uint8_t ins;
     uint8_t p1;
@@ -42,8 +41,7 @@ struct nfc_tech_iso7816_c_apdu
     size_t maxRespLength;
 };
 
-struct nfc_tech_iso7816_r_apdu
+struct nfc_tech_iso7816_r_apdu {
-{
     buffer_t dataOut;
     uint16_t sw;
 };
@@ -60,8 +58,7 @@ typedef void (*nfc_tech_iso7816_disconnected_cb)(nfc_tech_iso7816_t* pIso7816, b
 struct nfc_tech_iso7816_app;
 typedef struct nfc_tech_iso7816_app nfc_tech_iso7816_app_t;
 
-struct nfc_tech_iso7816
+struct nfc_tech_iso7816 {
-{
     nfc_tech_isodep_target_t isoDepTarget;
 
     nfc_tech_iso7816_app_t *pAppList;

features/nfc/stack/tech/iso7816/iso7816_app.h

@@ -36,8 +36,7 @@ typedef struct nfc_tech_iso7816_app nfc_tech_iso7816_app_t;
 
 typedef void (*nfc_tech_iso7816_app_cb)(nfc_tech_iso7816_app_t *pIso7816App, void *pUserData);
 
-struct nfc_tech_iso7816_app
+struct nfc_tech_iso7816_app {
-{
     nfc_tech_iso7816_t *pIso7816;
 
     const uint8_t *aid;

features/nfc/stack/tech/isodep/isodep.h

@@ -36,8 +36,7 @@ typedef void (*nfc_tech_isodep_cb_t)(nfc_tech_isodep_t* pIsodep, nfc_err_t ret,
 typedef void (*nfc_tech_isodep_disconnected_cb)(nfc_tech_isodep_t *pIsodep, bool deselected, void *pUserData);
 
 
-struct nfc_tech_isodep
+struct nfc_tech_isodep {
-{
 
 };
 

features/nfc/stack/tech/isodep/isodep_target.c

@@ -74,8 +74,7 @@
 #define FWI 14 //Max time before answer is ~ 19.3ms
 
 typedef enum __dep_type dep_type_t;
-enum __dep_type
+enum __dep_type {
-{
     dep_type_information,
     dep_type_response,
     dep_type_supervisory,
@@ -144,8 +143,7 @@ void nfc_tech_isodep_target_disconnect(nfc_tech_isodep_target_t* pIsodepTarget)
 
 nfc_err_t nfc_tech_isodep_target_transmit(nfc_tech_isodep_target_t *pIsodepTarget, istream_t *pStream, nfc_tech_isodep_cb_t cb, void *pUserData)
 {
-  if( pIsodepTarget->dep.pReqStream != NULL )
+    if (pIsodepTarget->dep.pReqStream != NULL) {
-  {
         return NFC_ERR_BUSY;
     }
 
@@ -154,8 +152,7 @@ nfc_err_t nfc_tech_isodep_target_transmit(nfc_tech_isodep_target_t* pIsodepTarge
     pIsodepTarget->dep.pResUserData = pUserData;
 
     //Do we need to start transceiving?
-  if( pIsodepTarget->commands.state == ISO_DEP_TARGET_COMMANDS_DEP_REQ_RECVD )
+    if (pIsodepTarget->commands.state == ISO_DEP_TARGET_COMMANDS_DEP_REQ_RECVD) {
-  {
         command_reply(pIsodepTarget, false); //Force reply
     }
 
@@ -164,8 +161,7 @@ nfc_err_t nfc_tech_isodep_target_transmit(nfc_tech_isodep_target_t* pIsodepTarge
 
 nfc_err_t nfc_tech_isodep_target_receive(nfc_tech_isodep_target_t *pIsodepTarget, ostream_t *pStream, nfc_tech_isodep_cb_t cb, void *pUserData)
 {
-  if( pIsodepTarget->dep.pResStream != NULL )
+    if (pIsodepTarget->dep.pResStream != NULL) {
-  {
         return NFC_ERR_BUSY;
     }
 
@@ -199,17 +195,13 @@ void dep_init(nfc_tech_isodep_target_t* pIsodepTarget)
 bool dep_ready(nfc_tech_isodep_target_t *pIsodepTarget)
 {
     //Anything to send back?
-  if( pIsodepTarget->dep.frameState != ISO_DEP_TARGET_DEP_FRAME_INFORMATION_RECEIVED )
+    if (pIsodepTarget->dep.frameState != ISO_DEP_TARGET_DEP_FRAME_INFORMATION_RECEIVED) {
-  {
         return true;
     }
 
-  if( (pIsodepTarget->dep.pResStream != NULL) )
+    if ((pIsodepTarget->dep.pResStream != NULL)) {
-  {
         return true;
-  }
+    } else {
-  else
-  {
         return false;
     }
 }
@@ -226,18 +218,15 @@ void dep_req_information(nfc_tech_isodep_target_t* pIsodepTarget, buffer_t* pReq
     pIsodepTarget->commands.state = ISO_DEP_TARGET_COMMANDS_ATS_RES_SENT;
 
     if (!pIsodepTarget->dep.chaining
-      && (pIsodepTarget->dep.pResStream != NULL) )
+            && (pIsodepTarget->dep.pResStream != NULL)) {
-  {
         //Sent the full frame
         pIsodepTarget->dep.pResStream = NULL;
         pIsodepTarget->dep.resCb((nfc_tech_isodep_t *)pIsodepTarget, NFC_OK, pIsodepTarget->dep.pResUserData);
     }
-  if( pIsodepTarget->dep.pReqStream != NULL )
+    if (pIsodepTarget->dep.pReqStream != NULL) {
-  {
         // Pull more
         ostream_push(pIsodepTarget->dep.pReqStream, pReq, !moreInformation);
-    if(!moreInformation)
+        if (!moreInformation) {
-    {
             //Got the full frame
             pIsodepTarget->dep.pReqStream = NULL;
             pIsodepTarget->dep.reqCb((nfc_tech_isodep_t *)pIsodepTarget, NFC_OK, pIsodepTarget->dep.pReqUserData);
@@ -251,19 +240,13 @@ void dep_req_information(nfc_tech_isodep_target_t* pIsodepTarget, buffer_t* pReq
 
 void dep_req_response(nfc_tech_isodep_target_t *pIsodepTarget, bool ack, uint8_t blockNumber)
 {
-  if( blockNumber != pIsodepTarget->dep.blockNumber )
+    if (blockNumber != pIsodepTarget->dep.blockNumber) {
-  {
         //Should be NACK
         pIsodepTarget->dep.frameState = ISO_DEP_TARGET_DEP_FRAME_NACK_DIFF_BLOCK_NUMBER_RECEIVED;
-  }
+    } else {
-  else
+        if (ack) {
-  {
-    if(ack)
-    {
             pIsodepTarget->dep.frameState = ISO_DEP_TARGET_DEP_FRAME_ACK_RECEIVED;
-    }
+        } else {
-    else
-    {
             pIsodepTarget->dep.frameState = ISO_DEP_TARGET_DEP_FRAME_NACK_RECEIVED;
         }
     }
@@ -273,16 +256,12 @@ void dep_req_supervisory(nfc_tech_isodep_target_t* pIsodepTarget, bool wtxNDesel
 {
     (void) wtxm;
 
-  if(wtxNDeselect)
+    if (wtxNDeselect) {
-  {
+        if ((pIsodepTarget->dep.frameState != ISO_DEP_TARGET_DEP_FRAME_WTX_SENT)) {
-    if((pIsodepTarget->dep.frameState != ISO_DEP_TARGET_DEP_FRAME_WTX_SENT))
-    {
             NFC_WARN("Unexpected WTX frame");
         }
         pIsodepTarget->dep.frameState = ISO_DEP_TARGET_DEP_FRAME_WTX_RECEIVED;
-  }
+    } else {
-  else
-  {
         pIsodepTarget->dep.frameState = ISO_DEP_TARGET_DEP_FRAME_DESELECT_RECEIVED;
     }
 }
@@ -290,33 +269,24 @@ void dep_req_supervisory(nfc_tech_isodep_target_t* pIsodepTarget, bool wtxNDesel
 dep_type_t dep_res_type(nfc_tech_isodep_target_t *pIsodepTarget)
 {
     dep_type_t depType;
-  switch( pIsodepTarget->dep.frameState )
+    switch (pIsodepTarget->dep.frameState) {
-  {
         case ISO_DEP_TARGET_DEP_FRAME_DESELECT_RECEIVED:
             depType = dep_type_supervisory; //Deselect
             break;
         case ISO_DEP_TARGET_DEP_FRAME_INFORMATION_RECEIVED:
         case ISO_DEP_TARGET_DEP_FRAME_WTX_RECEIVED:
-    if( pIsodepTarget->dep.chaining ) //Need to ack?
+            if (pIsodepTarget->dep.chaining) { //Need to ack?
-    {
                 depType = dep_type_response;
-    }
+            } else if (pIsodepTarget->dep.pResStream != NULL) { //Anything to send back?
-    else if( pIsodepTarget->dep.pResStream != NULL ) //Anything to send back?
-    {
                 depType = dep_type_information;
-    }
+            } else {
-    else
-    {
                 depType = dep_type_supervisory; //WTX
             }
             break;
         case ISO_DEP_TARGET_DEP_FRAME_ACK_RECEIVED:
-    if(( pIsodepTarget->dep.pResStream != NULL ) && ( pIsodepTarget->dep.chaining ))
+            if ((pIsodepTarget->dep.pResStream != NULL) && (pIsodepTarget->dep.chaining)) {
-    {
                 depType = dep_type_information;
-    }
+            } else {
-    else
-    {
                 depType = dep_type_supervisory; //WTX
             }
             break;
@@ -336,17 +306,13 @@ dep_type_t dep_res_type(nfc_tech_isodep_target_t* pIsodepTarget)
 void dep_res_information(nfc_tech_isodep_target_t *pIsodepTarget, size_t maxLength, buffer_t **ppRes, bool *pMoreInformation, uint8_t *pBlockNumber)
 {
     *pBlockNumber = pIsodepTarget->dep.blockNumber;
-  if( pIsodepTarget->dep.frameState != ISO_DEP_TARGET_DEP_FRAME_NACK_RECEIVED )
+    if (pIsodepTarget->dep.frameState != ISO_DEP_TARGET_DEP_FRAME_NACK_RECEIVED) {
-  {
+        if (pIsodepTarget->dep.pResStream != NULL) {
-    if( pIsodepTarget->dep.pResStream != NULL )
-    {
             bool lastFrame = true;
             istream_pull(pIsodepTarget->dep.pResStream, &pIsodepTarget->dep.res, &lastFrame, maxLength);
             pIsodepTarget->dep.chaining = !lastFrame;
         }
-  }
+    } else {
-  else
-  {
         //Retransmit previous frame (leave it as it is)
     }
     *ppRes = &pIsodepTarget->dep.res;
@@ -364,13 +330,10 @@ void dep_res_response(nfc_tech_isodep_target_t* pIsodepTarget, bool* pAck, uint8
 
 void dep_res_supervisory(nfc_tech_isodep_target_t *pIsodepTarget, bool *pWtxNDeselect, uint8_t *pWtxm)
 {
-  if( pIsodepTarget->dep.frameState == ISO_DEP_TARGET_DEP_FRAME_DESELECT_RECEIVED )
+    if (pIsodepTarget->dep.frameState == ISO_DEP_TARGET_DEP_FRAME_DESELECT_RECEIVED) {
-  {
         *pWtxNDeselect = false;
         pIsodepTarget->dep.frameState = ISO_DEP_TARGET_DEP_FRAME_DESELECT_SENT;
-  }
+    } else {
-  else
-  {
         *pWtxNDeselect = true;
         *pWtxm = WTXM_DEFAULT;
         pIsodepTarget->dep.frameState = ISO_DEP_TARGET_DEP_FRAME_WTX_SENT;
@@ -380,18 +343,15 @@ void dep_res_supervisory(nfc_tech_isodep_target_t* pIsodepTarget, bool *pWtxNDes
 void dep_disconnected(nfc_tech_isodep_target_t *pIsodepTarget, bool deselected)
 {
     //Call callbacks if needed
-  if( pIsodepTarget->dep.pReqStream != NULL )
+    if (pIsodepTarget->dep.pReqStream != NULL) {
-  {
         pIsodepTarget->dep.reqCb((nfc_tech_isodep_t *)pIsodepTarget, NFC_ERR_DISCONNECTED, pIsodepTarget->dep.pReqUserData);
         pIsodepTarget->dep.pReqStream = NULL;
     }
-  if( pIsodepTarget->dep.pReqStream != NULL )
+    if (pIsodepTarget->dep.pReqStream != NULL) {
-  {
         pIsodepTarget->dep.resCb((nfc_tech_isodep_t *)pIsodepTarget, NFC_ERR_DISCONNECTED, pIsodepTarget->dep.pResUserData);
         pIsodepTarget->dep.pResStream = NULL;
     }
-  if( pIsodepTarget->commands.state != ISO_DEP_TARGET_COMMANDS_DISCONNECTED )
+    if (pIsodepTarget->commands.state != ISO_DEP_TARGET_COMMANDS_DISCONNECTED) {
-  {
         pIsodepTarget->commands.state = ISO_DEP_TARGET_COMMANDS_DISCONNECTED;
         pIsodepTarget->disconnectedCb((nfc_tech_isodep_t *)pIsodepTarget, deselected, pIsodepTarget->pUserData);
     }
@@ -412,13 +372,11 @@ void command_init(nfc_tech_isodep_target_t* pIsodepTarget)
 nfc_err_t command_ats_req(nfc_tech_isodep_target_t *pIsodepTarget)
 {
     //Check we are in a correct state -- this should be the first command received
-  if( pIsodepTarget->commands.state != ISO_DEP_TARGET_COMMANDS_CONNECTING )
+    if (pIsodepTarget->commands.state != ISO_DEP_TARGET_COMMANDS_CONNECTING) {
-  {
         return NFC_ERR_PROTOCOL;
     }
 
-  if( buffer_reader_readable(pIsodepTarget->commands.pReq) < 2 )
+    if (buffer_reader_readable(pIsodepTarget->commands.pReq) < 2) {
-  {
         NFC_ERR("Payload too short");
         return NFC_ERR_PROTOCOL;
     }
@@ -440,13 +398,11 @@ nfc_err_t command_ats_req(nfc_tech_isodep_target_t* pIsodepTarget)
 
 nfc_err_t command_dep_req(nfc_tech_isodep_target_t *pIsodepTarget)
 {
-  if( pIsodepTarget->commands.state < ISO_DEP_TARGET_COMMANDS_ATS_RES_SENT )
+    if (pIsodepTarget->commands.state < ISO_DEP_TARGET_COMMANDS_ATS_RES_SENT) {
-  {
         return NFC_ERR_PROTOCOL;
     }
 
-  if( buffer_reader_readable(pIsodepTarget->commands.pReq) < 1 )
+    if (buffer_reader_readable(pIsodepTarget->commands.pReq) < 1) {
-  {
         NFC_ERR("Payload too short");
         return NFC_ERR_PROTOCOL;
     }
@@ -477,8 +433,7 @@ nfc_err_t command_dep_req(nfc_tech_isodep_target_t* pIsodepTarget)
     */
 
     uint8_t wtxm = 0;
-  switch( PCB_TYPE(pcb) )
+    switch (PCB_TYPE(pcb)) {
-  {
         case I_BLOCK_PCB:
             dep_req_information(pIsodepTarget, pIsodepTarget->commands.pReq, PCB_CHAINING(pcb), PCB_BLOCK_TOGGLE(pcb));
             break;
@@ -486,10 +441,8 @@ nfc_err_t command_dep_req(nfc_tech_isodep_target_t* pIsodepTarget)
             dep_req_response(pIsodepTarget, !PCB_NACK(pcb), PCB_BLOCK_TOGGLE(pcb));
             break;
         case S_BLOCK_PCB:
-    if( PCB_WTX(pcb) )
+            if (PCB_WTX(pcb)) {
-    {
+                if (buffer_reader_readable(pIsodepTarget->commands.pReq) < 1) {
-      if( buffer_reader_readable(pIsodepTarget->commands.pReq) < 1 )
-      {
                     NFC_ERR("Payload too short");
                     return NFC_ERR_PROTOCOL;
                 }
@@ -510,8 +463,7 @@ nfc_err_t command_dep_req(nfc_tech_isodep_target_t* pIsodepTarget)
 nfc_err_t command_ats_res(nfc_tech_isodep_target_t *pIsodepTarget)
 {
     //Send ATS back
-  if (buffer_builder_writeable(&pIsodepTarget->commands.respBldr) < 5 )
+    if (buffer_builder_writeable(&pIsodepTarget->commands.respBldr) < 5) {
-  {
         return NFC_ERR_BUFFER_TOO_SMALL;
     }
 
@@ -562,8 +514,7 @@ nfc_err_t command_dep_res(nfc_tech_isodep_target_t* pIsodepTarget)
 
     size_t maxLength = pIsodepTarget->commands.inPayloadSize - 1;
 
-  switch( dep_res_type(pIsodepTarget) )
+    switch (dep_res_type(pIsodepTarget)) {
-  {
         case dep_type_information:
             dep_res_information(pIsodepTarget, maxLength, &pDepBuf, &moreInformation, &blockNumber);
             pcb = BUILD_I_BLOCK_PCB(moreInformation, false, false, blockNumber);
@@ -585,12 +536,9 @@ nfc_err_t command_dep_res(nfc_tech_isodep_target_t* pIsodepTarget)
         buffer_builder_write_nu8(&pIsodepTarget->commands.respBldr, pIsodepTarget->commands.did);
       }
     */
-  if( pDepBuf != NULL )
+    if (pDepBuf != NULL) {
-  {
         buffer_set_next(buffer_builder_buffer(&pIsodepTarget->commands.respBldr), pDepBuf);
-  }
+    } else if (wtxNDeselect) {
-  else if(wtxNDeselect)
-  {
         buffer_builder_write_nu8(&pIsodepTarget->commands.respBldr, wtxm);
     }
 
@@ -604,16 +552,14 @@ void command_reply(nfc_tech_isodep_target_t* pIsodepTarget, bool depWait)
     nfc_err_t ret;
 
     //Check whether we want to reply or wait for the higher layer to send us something
-  if((pIsodepTarget->commands.state == ISO_DEP_TARGET_COMMANDS_DEP_REQ_RECVD) && depWait && !dep_ready(pIsodepTarget))
+    if ((pIsodepTarget->commands.state == ISO_DEP_TARGET_COMMANDS_DEP_REQ_RECVD) && depWait && !dep_ready(pIsodepTarget)) {
-  {
         return;
     }
 
     //Reply
     buffer_builder_reset(&pIsodepTarget->commands.respBldr);
 
-  switch(pIsodepTarget->commands.state)
+    switch (pIsodepTarget->commands.state) {
-  {
         case ISO_DEP_TARGET_COMMANDS_ATS_REQ_RECVD:
             ret = command_ats_res(pIsodepTarget);
             break;
@@ -627,8 +573,7 @@ void command_reply(nfc_tech_isodep_target_t* pIsodepTarget, bool depWait)
             return;
     }
 
-  if(ret)
+    if (ret) {
-  {
         NFC_ERR("Error %d", ret);
         //Go back to receive mode
         nfc_transceiver_transceive(pIsodepTarget->pTransceiver, command_transceiver_cb, pIsodepTarget);
@@ -637,12 +582,9 @@ void command_reply(nfc_tech_isodep_target_t* pIsodepTarget, bool depWait)
 
     NFC_DBG("Transceive");
 
-  if( pIsodepTarget->dep.frameState == ISO_DEP_TARGET_DEP_FRAME_DESELECT_SENT )
+    if (pIsodepTarget->dep.frameState == ISO_DEP_TARGET_DEP_FRAME_DESELECT_SENT) {
-  {
         transceiver_set_transceive_options(pIsodepTarget->pTransceiver, true, false, true);
-  }
+    } else {
-  else
-  {
         transceiver_set_transceive_options(pIsodepTarget->pTransceiver, true, true, false);
     }
 
@@ -659,14 +601,12 @@ void command_transceiver_cb(nfc_transceiver_t* pTransceiver, nfc_err_t ret, void
 {
     nfc_tech_isodep_target_t *pIsodepTarget = (nfc_tech_isodep_target_t *) pUserData;
 
-  if( ret == NFC_ERR_ABORTED )
+    if (ret == NFC_ERR_ABORTED) {
-  {
         // Just return
         return;
     }
 
-  if( pIsodepTarget->dep.frameState == ISO_DEP_TARGET_DEP_FRAME_DESELECT_SENT )
+    if (pIsodepTarget->dep.frameState == ISO_DEP_TARGET_DEP_FRAME_DESELECT_SENT) {
-  {
         //We are now disconnected (deselected)
         //Reset status
         dep_init(pIsodepTarget);
@@ -684,14 +624,11 @@ void command_transceiver_cb(nfc_transceiver_t* pTransceiver, nfc_err_t ret, void
     transceiver_set_write(pTransceiver, NULL);
     transceiver_set_transceive_options(pTransceiver, false, true, false);
 
-  if( ret == NFC_ERR_FIELD )
+    if (ret == NFC_ERR_FIELD) {
-  {
         NFC_WARN("Lost initiator");
         dep_disconnected(pIsodepTarget, false);
         return;
-  }
+    } else if (ret) {
-  else if(ret)
-  {
         //We should ignore this error and wait for another frame
         NFC_WARN("Got invalid frame (error %d)", ret);
 
@@ -705,8 +642,7 @@ void command_transceiver_cb(nfc_transceiver_t* pTransceiver, nfc_err_t ret, void
     DBG_BLOCK(buffer_dump(pDataInitiator);)
 
     //Framing is handled by transceiver
-  if( (buffer_reader_readable(pDataInitiator) < 1) )
+    if ((buffer_reader_readable(pDataInitiator) < 1)) {
-  {
         NFC_ERR("Empty initiator message");
 
         //Go back to receive mode
@@ -721,8 +657,7 @@ void command_transceiver_cb(nfc_transceiver_t* pTransceiver, nfc_err_t ret, void
     buffer_dup(&dataInitiatorDup, pDataInitiator);
     uint8_t req = buffer_read_nu8(&dataInitiatorDup);
 
-  switch(req)
+    switch (req) {
-  {
         case RATS:
             ret = command_ats_req(pIsodepTarget);
             break;
@@ -731,8 +666,7 @@ void command_transceiver_cb(nfc_transceiver_t* pTransceiver, nfc_err_t ret, void
             break;
     }
 
-  if(ret)
+    if (ret) {
-  {
         NFC_ERR("Error %d", ret);
 
         //Go back to receive mode

features/nfc/stack/tech/isodep/isodep_target.h

@@ -35,13 +35,11 @@ struct nfc_tech_isodep_target;
 typedef struct nfc_tech_isodep_target nfc_tech_isodep_target_t;
 
 typedef struct nfc_tech_isodep_target nfc_tech_isodep_target_t;
-struct nfc_tech_isodep_target
+struct nfc_tech_isodep_target {
-{
     nfc_tech_isodep_t isodep;
     nfc_transceiver_t *pTransceiver;
 
-  struct
+    struct {
-  {
         ostream_t *pReqStream;
         istream_t *pResStream;
 
@@ -56,8 +54,7 @@ struct nfc_tech_isodep_target
 
         uint8_t blockNumber;
 
-    enum
+        enum {
-    {
             ISO_DEP_TARGET_DEP_FRAME_IDLE,
             ISO_DEP_TARGET_DEP_FRAME_WTX_RECEIVED,
             ISO_DEP_TARGET_DEP_FRAME_WTX_SENT,
@@ -72,10 +69,8 @@ struct nfc_tech_isodep_target
             ISO_DEP_TARGET_DEP_FRAME_DESELECT_SENT,
         } frameState;
     } dep;
-  struct
+    struct {
-  {
+        enum {
-    enum
-    {
             ISO_DEP_TARGET_COMMANDS_DISCONNECTED,
 
             ISO_DEP_TARGET_COMMANDS_CONNECTING,

features/nfc/stack/tech/type4/type4_target.c

@@ -98,8 +98,7 @@ void app_selected( nfc_tech_iso7816_app_t* pIso7816App, void* pUserData )
     buffer_builder_write_nu16(&pType4Target->ndefFileBldr, buffer_reader_readable(buffer_builder_buffer(ndef_msg_buffer_builder(pType4Target->pNdef))));
 
     //Pad NDEF file with 0s
-  while( buffer_builder_writeable( ndef_msg_buffer_builder(pType4Target->pNdef) ) > 0 )
+    while (buffer_builder_writeable(ndef_msg_buffer_builder(pType4Target->pNdef)) > 0) {
-  {
         buffer_builder_write_nu8(ndef_msg_buffer_builder(pType4Target->pNdef), 0);
     }
 
@@ -122,20 +121,16 @@ void app_deselected( nfc_tech_iso7816_app_t* pIso7816App, void* pUserData )
 
     DBG("Deselected");
 
-  if(pType4Target->written)
+    if (pType4Target->written) {
-  {
         DBG("New content has been written");
         //Try to parse NDEF
         //Set buffer length based on file header
         size_t length = buffer_read_nu16(buffer_builder_buffer(&pType4Target->ndefFileBldr));
         DBG("Length is %lu", length);
-    if( length < buffer_builder_writeable( ndef_msg_buffer_builder(pType4Target->pNdef) ))
+        if (length < buffer_builder_writeable(ndef_msg_buffer_builder(pType4Target->pNdef))) {
-    {
             buffer_builder_set_write_offset(ndef_msg_buffer_builder(pType4Target->pNdef), length);
             ndef_msg_decode(pType4Target->pNdef);
-    }
+        } else {
-    else
-    {
             ERR("Invalid length");
         }
     }
@@ -157,34 +152,26 @@ void app_apdu( nfc_tech_iso7816_app_t* pIso7816App, void* pUserData )
     nfc_tech_iso7816_r_apdu_t *pRApdu = nfc_tech_iso7816_app_r_apdu(pIso7816App);
 
     nfc_err_t ret;
-  switch(pCApdu->ins)
+    switch (pCApdu->ins) {
-  {
         case ISO7816_INS_SELECT:
-    switch (pCApdu->p1)
+            switch (pCApdu->p1) {
-    {
                 case 0x00: //Selection by ID
                 case 0x02: //Selection by child ID
-      if ( buffer_reader_readable(&pCApdu->dataIn) != 2)
+                    if (buffer_reader_readable(&pCApdu->dataIn) != 2) {
-      {
                         pRApdu->sw = ISO7816_SW_NOT_FOUND;
                         break;
                     }
 
                     uint16_t file = buffer_read_nu16(&pCApdu->dataIn);
-      if ( file == NDEF_FILE )
+                    if (file == NDEF_FILE) {
-      {
                         pType4Target->selFile = NDEF_FILE;
                         DBG("NDEF File selected");
                         pRApdu->sw = ISO7816_SW_OK;
-      }
+                    } else if (file == CC_FILE) {
-      else if ( file == CC_FILE )
-      {
                         pType4Target->selFile = CC_FILE;
                         DBG("CC File selected");
                         pRApdu->sw = ISO7816_SW_OK;
-      }
+                    } else {
-      else
-      {
                         //file = DEFAULT_FILE;
                         DBG("Could not select file %04X", file);
                         pRApdu->sw = ISO7816_SW_NOT_FOUND;
@@ -198,14 +185,11 @@ void app_apdu( nfc_tech_iso7816_app_t* pIso7816App, void* pUserData )
         case 0xB0: //Read binary
             DBG("Trying to read %d bytes at offset %d from file %04x", pCApdu->maxRespLength, (pCApdu->p1 << 8) | pCApdu->p2, pType4Target->selFile);
             ret = data_read(pType4Target, &pRApdu->dataOut, pType4Target->selFile, (pCApdu->p1 << 8) | pCApdu->p2, pCApdu->maxRespLength);
-    if (ret == NFC_OK)
+            if (ret == NFC_OK) {
-    {
                 DBG("Read %d bytes", buffer_reader_readable(&pRApdu->dataOut));
                 DBG_BLOCK(buffer_dump(&pRApdu->dataOut);)
                 pRApdu->sw = ISO7816_SW_OK;
-    }
+            } else {
-    else
-    {
                 DBG("Failed with ret code %d", ret);
                 pRApdu->sw = ISO7816_SW_WRONG_LENGTH;
             }
@@ -213,14 +197,11 @@ void app_apdu( nfc_tech_iso7816_app_t* pIso7816App, void* pUserData )
         case 0xD6: //Update binary
             DBG("Trying to write %d bytes at offset %d to file %04x", buffer_reader_readable(&pCApdu->dataIn), (pCApdu->p1 << 8) | pCApdu->p2, pType4Target->selFile);
             ret = data_write(pType4Target, &pCApdu->dataIn, pType4Target->selFile, (pCApdu->p1 << 8) | pCApdu->p2);
-    if (ret == NFC_OK)
+            if (ret == NFC_OK) {
-    {
                 DBG("OK");
                 pRApdu->sw = ISO7816_SW_OK;
                 pType4Target->written = true;
-    }
+            } else {
-    else
-    {
                 DBG("Failed with ret code %d", ret);
                 pRApdu->sw = ISO7816_SW_WRONG_LENGTH;
             }
@@ -237,8 +218,7 @@ void app_apdu( nfc_tech_iso7816_app_t* pIso7816App, void* pUserData )
 nfc_err_t data_read(nfc_tech_type4_target_t *pType4Target, buffer_t *pBuf, uint16_t file, size_t off, size_t len)
 {
     buffer_t *pFile;
-  switch(file)
+    switch (file) {
-  {
         case CC_FILE:
             pFile = buffer_builder_buffer(&pType4Target->ccFileBldr);
             break;
@@ -249,15 +229,13 @@ nfc_err_t data_read(nfc_tech_type4_target_t* pType4Target, buffer_t* pBuf, uint1
             return NFC_ERR_NOT_FOUND;
     }
 
-  if( off > buffer_reader_readable(pFile) )
+    if (off > buffer_reader_readable(pFile)) {
-  {
         return NFC_ERR_LENGTH;
     }
 
     buffer_read_n_skip(pFile, off);
 
-  if( len > buffer_reader_readable(pFile))
+    if (len > buffer_reader_readable(pFile)) {
-  {
         len = buffer_reader_readable(pFile);
     }
 
@@ -269,8 +247,7 @@ nfc_err_t data_read(nfc_tech_type4_target_t* pType4Target, buffer_t* pBuf, uint1
 nfc_err_t data_write(nfc_tech_type4_target_t *pType4Target, buffer_t *pBuf, uint16_t file, size_t off)
 {
     buffer_t *pFile;
-  switch(file)
+    switch (file) {
-  {
         case NDEF_FILE:
             pFile = buffer_builder_buffer(&pType4Target->ndefFileBldr);
             break;
@@ -281,20 +258,17 @@ nfc_err_t data_write(nfc_tech_type4_target_t* pType4Target, buffer_t* pBuf, uint
 
     size_t len = buffer_reader_readable(pBuf);
 
-  if( off > buffer_reader_readable(pFile) )
+    if (off > buffer_reader_readable(pFile)) {
-  {
         return NFC_ERR_LENGTH;
     }
 
     buffer_read_n_skip(pFile, off);
 
-  if( len > buffer_reader_readable(pFile) )
+    if (len > buffer_reader_readable(pFile)) {
-  {
         len = buffer_reader_readable(pFile);
     }
 
-  while( len > 0 )
+    while (len > 0) {
-  {
         size_t cpy;
         buffer_builder_t builder;
         buffer_dup(buffer_builder_buffer(&builder), pFile);

features/nfc/stack/tech/type4/type4_target.h

@@ -37,8 +37,7 @@ typedef struct nfc_tech_type4_target nfc_tech_type4_target_t;
 
 typedef void (*nfc_tech_type4_cb)(nfc_tech_type4_target_t *pType4Target, nfc_err_t ret, void *pUserData);
 
-struct nfc_tech_type4_target
+struct nfc_tech_type4_target {
-{
     nfc_tech_iso7816_app_t app;
 
     ndef_msg_t *pNdef;

features/nfc/stack/transceiver/pn512/pn512.c

@@ -60,8 +60,7 @@
 
 //PN 512 VTABLE
 
-static const transceiver_impl_t pn512_impl =
+static const transceiver_impl_t pn512_impl = {
-{
     .set_protocols = pn512_set_protocols,
     .poll = pn512_poll,
     .transceive = pn512_transceive,
@@ -159,8 +158,7 @@ nfc_err_t pn512_init(pn512_t* pPN512, nfc_transport_t* pTransport, nfc_scheduler
 
     DBGX_ENTER();
     NFC_DBG("Test result:");
-  while(pn512_fifo_length(pPN512))
+    while (pn512_fifo_length(pPN512)) {
-  {
         buffer_builder_t read_byte;
         buffer_builder_init(&read_byte, null_array_buf, 1);
 
@@ -177,8 +175,7 @@ nfc_err_t pn512_init(pn512_t* pPN512, nfc_transport_t* pTransport, nfc_scheduler
         NFC_DBG("PN512 version %02x", r);
     )
 
-  if((r != 0x82) && (r != 0xB1) && (r != 0xB2))
+    if ((r != 0x82) && (r != 0xB1) && (r != 0xB2)) {
-  {
         return NFC_ERR_UNSUPPORTED; //PN512 not found
     }
 
@@ -198,11 +195,9 @@ void pn512_set_protocols(nfc_transceiver_t* pTransceiver, nfc_tech_t initiators,
 {
     pn512_t *pPN512 = (pn512_t *) pTransceiver;
     //If different, reconfigure
-  if( memcmp(&initiators, &pPN512->config.initiators, sizeof(nfc_tech_t)) || memcmp(&targets, &pPN512->config.targets, sizeof(nfc_tech_t)) )
+    if (memcmp(&initiators, &pPN512->config.initiators, sizeof(nfc_tech_t)) || memcmp(&targets, &pPN512->config.targets, sizeof(nfc_tech_t))) {
-  {
         pPN512->config.initiators = initiators;
-    if( memcmp(&targets, &pPN512->config.targets, sizeof(nfc_tech_t)) )
+        if (memcmp(&targets, &pPN512->config.targets, sizeof(nfc_tech_t))) {
-    {
             pPN512->config.targets = targets;
             pn512_poll_setup(pPN512);
         }
@@ -234,24 +229,15 @@ void pn512_set_timeout(nfc_transceiver_t* pTransceiver, int timeout)
 void pn512_set_transceive_options(nfc_transceiver_t *pTransceiver, bool transmit, bool receive, bool repoll)
 {
     pn512_t *pPN512 = (pn512_t *) pTransceiver;
-  if( transmit && receive )
+    if (transmit && receive) {
-  {
         pPN512->nextFrameMode = pn512_transceive_mode_transceive;
-  }
+    } else if (transmit && repoll) {
-  else if(transmit && repoll)
-  {
         pPN512->nextFrameMode = pn512_transceive_mode_transmit_and_target_autocoll;
-  }
+    } else if (transmit) {
-  else if(transmit)
-  {
         pPN512->nextFrameMode = pn512_transceive_mode_transmit;
-  }
+    } else if (receive) {
-  else if(receive)
-  {
         pPN512->nextFrameMode = pn512_transceive_mode_receive;
-  }
+    } else {
-  else
-  {
         pPN512->nextFrameMode = pn512_transceive_mode_target_autocoll;
     }
 }
@@ -264,14 +250,12 @@ void pn512_set_transceive_framing(nfc_transceiver_t* pTransceiver, nfc_framing_t
     //Switch NFC tech if NFC DEP
     if (pTransceiver->active_tech.nfc_nfc_dep_a
             || pTransceiver->active_tech.nfc_nfc_dep_f_212
-      || pTransceiver->active_tech.nfc_nfc_dep_f_424 )
+            || pTransceiver->active_tech.nfc_nfc_dep_f_424) {
-  {
         //FIXME
         pTransceiver->active_tech.nfc_nfc_dep_a = 0;
         pTransceiver->active_tech.nfc_nfc_dep_f_212 = 0;
         pTransceiver->active_tech.nfc_nfc_dep_f_424 = 0;
-    switch(framing)
+        switch (framing) {
-    {
             case nfc_framing_target_a_106:
             case nfc_framing_initiator_a_106:
                 pTransceiver->active_tech.nfc_nfc_dep_a = 1;
@@ -293,8 +277,7 @@ void pn512_set_transceive_framing(nfc_transceiver_t* pTransceiver, nfc_framing_t
 void pn512_set_write(nfc_transceiver_t *pTransceiver, buffer_t *pWriteBuf)
 {
     pn512_t *pPN512 = (pn512_t *) pTransceiver;
-  if( pWriteBuf == NULL )
+    if (pWriteBuf == NULL) {
-  {
         buffer_init(&pPN512->writeBuf, NULL, 0);
         return;
     }
@@ -310,8 +293,7 @@ buffer_t* pn512_get_read(nfc_transceiver_t* pTransceiver)
 void pn512_set_last_byte_length(nfc_transceiver_t *pTransceiver, size_t lastByteLength)
 {
     pn512_t *pPN512 = (pn512_t *) pTransceiver;
-  if( (lastByteLength > 8) || (lastByteLength == 0) )
+    if ((lastByteLength > 8) || (lastByteLength == 0)) {
-  {
         lastByteLength = 8;
     }
     pPN512->writeLastByteLength = lastByteLength;
@@ -355,12 +337,9 @@ void pn512_sleep(nfc_transceiver_t* pTransceiver, bool sleep)
 {
     pn512_t *pPN512 = (pn512_t *) pTransceiver;
 
-  if(sleep)
+    if (sleep) {
-  {
         pn512_register_write(pPN512, PN512_REG_COMMAND, 0x30); //Receiver off + soft power down
-  }
+    } else {
-  else
-  {
         pn512_register_write(pPN512, PN512_REG_COMMAND, 0x00);
         while (pn512_register_read(pPN512, PN512_REG_COMMAND) & 0x10);
     }

features/nfc/stack/transceiver/pn512/pn512.h

@@ -34,8 +34,7 @@ typedef struct __pn512 pn512_t;
 #include "pn512_callback.h"
 #include "pn512_types.h"
 
-typedef enum __pn512_state
+typedef enum __pn512_state {
-{
     pn512_state_ready,
     pn512_state_target_autocoll,
     pn512_state_initiator_transceive_first_frame,
@@ -43,8 +42,7 @@ typedef enum __pn512_state
     pn512_state_transceive_last_frame,
 } pn512_state_t;
 
-typedef enum __pn512_transceive_mode
+typedef enum __pn512_transceive_mode {
-{
     pn512_transceive_mode_idle,
     pn512_transceive_mode_target_autocoll,
     pn512_transceive_mode_transmit,
@@ -53,21 +51,18 @@ typedef enum __pn512_transceive_mode
     pn512_transceive_mode_receive,
 } pn512_transceive_mode_t;
 
-typedef struct __pn512
+typedef struct __pn512 {
-{
     nfc_transceiver_t transceiver;
     //Impl specific
     pn512_registers_t registers;
     bool rf_on;
-  struct
+    struct {
-  {
         bool out;
         bool in;
     } crc;
     int timeout;
 
-  struct
+    struct {
-  {
         nfc_tech_t initiators;
         nfc_tech_t targets;
         polling_options_t options;
@@ -88,11 +83,9 @@ typedef struct __pn512
     uint8_t writeLastByteLength;
 
     //Task parameters
-  struct
+    struct {
-  {
         //Polling
-    struct
+        struct {
-    {
             enum {
                 pn512_polling_state_start_listening,
 
@@ -120,30 +113,24 @@ typedef struct __pn512
 
             pn512_cb_t cb;
         } poll;
-    struct
+        struct {
-    {
             pn512_cb_t cb;
             pn512_transceive_mode_t mode;
         } transceive;
-    struct
+        struct {
-    {
             pn512_cb_t cb;
         } rf;
-    struct
+        struct {
-    {
+            union {
-      union
-      {
                 // ISO A
-        struct
+                struct {
-        {
                     bool more_targets; // Collision detected
                     uint8_t cascade_level;
                     uint8_t cln[5];
                     uint8_t valid_bits; // valid bits within cascade level
                 } iso_a;
                 // ISO B
-        struct
+                struct {
-        {
                     bool more_targets; // Collision detected
                     uint8_t slots_num_exponent;
                     uint8_t slot_number;

features/nfc/stack/transceiver/pn512/pn512_cmd.c

@@ -125,8 +125,7 @@ void pn512_cmd_exec(pn512_t* pPN512, uint8_t cmd)
 nfc_err_t pn512_cmd_wait_idle(pn512_t *pPN512, int timeout)
 {
     (void) timeout;
-  while( pn512_cmd_get(pPN512) != PN512_CMD_IDLE )
+    while (pn512_cmd_get(pPN512) != PN512_CMD_IDLE) {
-  {
 
     }
     return NFC_OK;

features/nfc/stack/transceiver/pn512/pn512_hw.h

@@ -61,10 +61,8 @@ static inline void pn512_hw_read(pn512_t* pPN512, uint8_t addr, uint8_t* buf, si
 
 static inline void pn512_hw_write_buffer(pn512_t *pPN512, uint8_t addr, buffer_t *pData, size_t len)
 {
-  while( len > 0 )
+    while (len > 0) {
-  {
+        if (buffer_reader_readable(pData) == 0) {
-    if( buffer_reader_readable(pData) == 0 )
-    {
             return;
         }
         size_t cpyLen = MIN(len, buffer_reader_current_buffer_length(pData));
@@ -76,10 +74,8 @@ static inline void pn512_hw_write_buffer(pn512_t* pPN512, uint8_t addr, buffer_t
 
 static inline void pn512_hw_read_buffer(pn512_t *pPN512, uint8_t addr, buffer_builder_t *pData, size_t len)
 {
-  while( len > 0 )
+    while (len > 0) {
-  {
+        if (buffer_builder_writeable(pData) == 0) {
-    if( buffer_builder_writeable(pData) == 0 )
-    {
             return;
         }
         //Read payload

features/nfc/stack/transceiver/pn512/pn512_poll.c

@@ -61,61 +61,48 @@ void pn512_target_anticollision_complete(pn512_t* pPN512, nfc_err_t ret)
     bool felica = pPN512->config.targets.nfc_type3 || pPN512->config.targets.nfc_nfc_dep_f_212 || pPN512->config.targets.nfc_nfc_dep_f_424;
 
     nfc_transceiver_t *pTransceiver = &pPN512->transceiver;
-  if( ret )
+    if (ret) {
-  {
         NFC_WARN("Returned %d", ret);
         pn512_anticollision_callback(pPN512, ret);
         return;
     }
 
     //Data available in FIFO
-  if (pPN512->readLastByteLength != 8) //We should receive a full byte
+    if (pPN512->readLastByteLength != 8) { //We should receive a full byte
-  {
         NFC_WARN("Not enough data in FIFO");
         pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
         return;
     }
 
     //If successful, update state machine
-  if (iso14443a && felica)
+    if (iso14443a && felica) {
-  {
         //Update current protocol accordingly
         uint8_t txmode = pn512_register_read(pPN512, PN512_REG_TXMODE);
-    if ((txmode & 0x03) == 0x00)
+        if ((txmode & 0x03) == 0x00) {
-    {
             pn512_framing_set(pPN512, nfc_framing_target_a_106);
 
             NFC_DBG("A 106");
             felica = false;
-    }
+        } else if ((txmode & 0x03) == 0x02) {
-    else if ((txmode & 0x03) == 0x02)
+            if ((txmode & 0x70) == 0x20) {
-    {
-      if ((txmode & 0x70) == 0x20)
-      {
                 //424kbps
                 NFC_DBG("F 424");
                 pn512_framing_set(pPN512, nfc_framing_target_f_424);
-      }
+            } else {
-      else
-      {
                 //212kbps
                 NFC_DBG("F 212");
                 pn512_framing_set(pPN512, nfc_framing_target_f_212);
             }
             iso14443a = false;
-    }
+        } else {
-    else
-    {
             //Unsupported mode, exit
             pn512_anticollision_callback(pPN512, NFC_ERR_UNSUPPORTED);
             return;
         }
     }
 
-  if (iso14443a)
+    if (iso14443a) {
-  {
+        if (buffer_reader_readable(buffer_builder_buffer(&pPN512->readBufBldr)) == 0) {
-    if(buffer_reader_readable(buffer_builder_buffer(&pPN512->readBufBldr)) == 0)
-    {
             pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
             return;
         }
@@ -136,20 +123,13 @@ void pn512_target_anticollision_complete(pn512_t* pPN512, nfc_err_t ret)
         //Anything else --> NFC Type 2
 
         //First check if this could be NFC-DEP
-    if ( pPN512->config.targets.nfc_nfc_dep_a && (b0 == 0xF0) )
+        if (pPN512->config.targets.nfc_nfc_dep_a && (b0 == 0xF0)) {
-    {
             pTransceiver->active_tech.nfc_nfc_dep_a = true;
-    }
+        } else if (pPN512->config.targets.nfc_iso_dep_a && (b0 == 0xE0)) {
-    else if ( pPN512->config.targets.nfc_iso_dep_a && (b0 == 0xE0) )
-    {
             pTransceiver->active_tech.nfc_iso_dep_a = true;
-    }
+        } else if (pPN512->config.targets.nfc_type2) {
-    else if ( pPN512->config.targets.nfc_type2 )
-    {
             pTransceiver->active_tech.nfc_type2 = true;
-    }
+        } else {
-    else
-    {
             //Unknown tech, return error
             pn512_anticollision_callback(pPN512, NFC_ERR_UNSUPPORTED);
             return;
@@ -158,23 +138,15 @@ void pn512_target_anticollision_complete(pn512_t* pPN512, nfc_err_t ret)
         //Give control to higher layer
         pn512_anticollision_callback(pPN512, NFC_OK);
         return;
-  }
+    } else if (felica) {
-  else if(felica)
-  {
         //First check if this could be NFC-DEP
-    if ( (pPN512->config.targets.nfc_nfc_dep_f_212 || pPN512->config.targets.nfc_nfc_dep_f_424) )
+        if ((pPN512->config.targets.nfc_nfc_dep_f_212 || pPN512->config.targets.nfc_nfc_dep_f_424)) {
-    {
+            if (pPN512->framing == nfc_framing_target_f_424) {
-      if(pPN512->framing == nfc_framing_target_f_424)
-      {
                 pTransceiver->active_tech.nfc_nfc_dep_f_424 = true;
-      }
+            } else {
-      else
-      {
                 pTransceiver->active_tech.nfc_nfc_dep_f_212 = true;
             }
-    }
+        } else {
-    else
-    {
             pn512_anticollision_callback(pPN512, NFC_ERR_UNSUPPORTED);
             return;
         }
@@ -251,8 +223,7 @@ void pn512_initiator_isoa_anticollision_atqa(pn512_t* pPN512, nfc_err_t ret)
     // Clear collisions register
     // FIXME PN512 Anomaly: pn512_register_write(pPN512, PN512_REG_COLL, 0x80); // Set MSB to 1, to treat collisions as errors
 
-  if (ret && (ret != NFC_ERR_COLLISION)) // There might be collisions here
+    if (ret && (ret != NFC_ERR_COLLISION)) { // There might be collisions here
-  {
         NFC_WARN("Did not receive ATQA: error %d", ret);
         pn512_anticollision_callback(pPN512, NFC_ERR_NOPEER);
         return;
@@ -260,8 +231,7 @@ void pn512_initiator_isoa_anticollision_atqa(pn512_t* pPN512, nfc_err_t ret)
 
     buffer_t *pResp = pn512_get_read((nfc_transceiver_t *)pPN512);
 
-  if (buffer_reader_readable(pResp) != 2)
+    if (buffer_reader_readable(pResp) != 2) {
-  {
         NFC_WARN("Wrong length (%u bytes)", buffer_reader_readable(pResp));
         pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
         return;
@@ -293,8 +263,7 @@ void pn512_initiator_isoa_anticollision_cascade_1(pn512_t* pPN512)
 
     NFC_DBG("SEL - cascade level %u,  %u valid bits - NVB %u", pPN512->anticollision.iso_a.cascade_level, pPN512->anticollision.iso_a.valid_bits, NVB(pPN512->anticollision.iso_a.valid_bits));
 
-  if( pPN512->anticollision.iso_a.valid_bits > 0 )
+    if (pPN512->anticollision.iso_a.valid_bits > 0) {
-  {
         // Transmit first part of uid
         buffer_builder_write_n_bytes(pDataOutBldr, pPN512->anticollision.iso_a.cln, (pPN512->anticollision.iso_a.valid_bits >> 3) + ((pPN512->anticollision.iso_a.valid_bits & 0x7) ? 1 : 0));
         pn512_set_last_byte_length((nfc_transceiver_t *)pPN512, pPN512->anticollision.iso_a.valid_bits & 0x7);
@@ -321,8 +290,7 @@ void pn512_initiator_isoa_anticollision_cascade_2(pn512_t* pPN512, nfc_err_t ret
     // Load & clear collisions register
     // FIXME PN512 Anomaly: pn512_register_write(pPN512, PN512_REG_COLL, 0x80); // Set MSB to 1, to treat collisions as errors
 
-  if (ret && (ret != NFC_ERR_COLLISION)) // There might be collisions here
+    if (ret && (ret != NFC_ERR_COLLISION)) { // There might be collisions here
-  {
         NFC_WARN("Did not receive response: error %d", ret);
         pn512_anticollision_callback(pPN512, ret);
         return;
@@ -333,8 +301,7 @@ void pn512_initiator_isoa_anticollision_cascade_2(pn512_t* pPN512, nfc_err_t ret
 
     // Check for collision
     uint8_t valid_bits = expected_resp_bits;
-  if( ret == NFC_ERR_COLLISION )
+    if (ret == NFC_ERR_COLLISION) {
-  {
         uint8_t coll_reg = pn512_register_read(pPN512, PN512_REG_COLL);
 
         // FIXME - PN512 error
@@ -342,29 +309,24 @@ void pn512_initiator_isoa_anticollision_cascade_2(pn512_t* pPN512, nfc_err_t ret
         {
             valid_bits = (coll_reg & 0x1f);
 
-      if(valid_bits == 0)
+            if (valid_bits == 0) {
-      {
                 valid_bits = 32;
             }
 
             valid_bits--;
 
             NFC_DBG("Collision detected, %u valid bits", valid_bits);
-      if( valid_bits < expected_resp_bits )
+            if (valid_bits < expected_resp_bits) {
-      {
                 // Collision detected
                 pPN512->anticollision.iso_a.more_targets = true;
-      }
+            } else {
-      else
-      {
                 valid_bits = expected_resp_bits;
             }
         }
     }
 
     size_t resp_sz = (valid_bits >> 3) + ((valid_bits & 0x7) ? 1 : 0);
-  if( buffer_reader_readable(pResp) < resp_sz )
+    if (buffer_reader_readable(pResp) < resp_sz) {
-  {
         (void) pn512_register_read(pPN512, PN512_REG_COLL);
 
         NFC_WARN("Wrong length (%u instead of %u - valid bits %u)", buffer_reader_readable(pResp), resp_sz, valid_bits);
@@ -386,14 +348,12 @@ void pn512_initiator_isoa_anticollision_cascade_2(pn512_t* pPN512, nfc_err_t ret
     bufIn[pPN512->anticollision.iso_a.valid_bits >> 3] &= 0xff >> ((8 - pPN512->anticollision.iso_a.valid_bits) & 0x7);
 
     // Now remember bits before collision
-  for(size_t p = 0; p < 5; p++)
+    for (size_t p = 0; p < 5; p++) {
-  {
         pPN512->anticollision.iso_a.cln[p] |= bufIn[p];
     }
 
     // If we have all bits, then check BCC, go to next step
-  if( pPN512->anticollision.iso_a.valid_bits < 5*8 ) // Collision, add a 1 at the end of known bits to resolve collision
+    if (pPN512->anticollision.iso_a.valid_bits < 5 * 8) { // Collision, add a 1 at the end of known bits to resolve collision
-  {
         pPN512->anticollision.iso_a.cln[pPN512->anticollision.iso_a.valid_bits >> 3] |= (1 << (pPN512->anticollision.iso_a.valid_bits & 0x7));
         pPN512->anticollision.iso_a.valid_bits++;
 
@@ -403,27 +363,22 @@ void pn512_initiator_isoa_anticollision_cascade_2(pn512_t* pPN512, nfc_err_t ret
     }
 
     //Check BCC if all bits are valid
-  if( pPN512->anticollision.iso_a.cln[4] != (pPN512->anticollision.iso_a.cln[0] ^ pPN512->anticollision.iso_a.cln[1] ^ pPN512->anticollision.iso_a.cln[2] ^ pPN512->anticollision.iso_a.cln[3]) )
+    if (pPN512->anticollision.iso_a.cln[4] != (pPN512->anticollision.iso_a.cln[0] ^ pPN512->anticollision.iso_a.cln[1] ^ pPN512->anticollision.iso_a.cln[2] ^ pPN512->anticollision.iso_a.cln[3])) {
-  {
         NFC_WARN("Wrong BCC %02X != %02X", bufIn[4], bufIn[0] ^ bufIn[1] ^ bufIn[2] ^ bufIn[3]);
         pn512_anticollision_callback(pPN512, NFC_ERR_COLLISION);
         return; //TODO handle this properly
     }
 
-  if( pPN512->anticollision.iso_a.cln[0] == CT )
+    if (pPN512->anticollision.iso_a.cln[0] == CT) {
-  {
         //Not the last cascade level
-    if( pPN512->anticollision.iso_a.cascade_level == 3 ) // not allowed
+        if (pPN512->anticollision.iso_a.cascade_level == 3) { // not allowed
-    {
             NFC_WARN("Cascade tag present in cascade level 3");
             pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
             return;
         }
         memcpy(&pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.uid[(pPN512->anticollision.iso_a.cascade_level - 1) * 3], &pPN512->anticollision.iso_a.cln[1], 3);
         pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.uidLength += 3;
-  }
+    } else {
-  else
-  {
         //Last cascade level
         memcpy(&pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.uid[(pPN512->anticollision.iso_a.cascade_level - 1) * 3], &pPN512->anticollision.iso_a.cln[0], 4);
         pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.uidLength += 4;
@@ -451,15 +406,13 @@ static void pn512_initiator_isoa_anticollision_cascade_3(pn512_t* pPN512, nfc_er
 {
     buffer_t *pResp = pn512_get_read((nfc_transceiver_t *)pPN512);
 
-  if(ret)
+    if (ret) {
-  {
         NFC_WARN("Did not receive response: error %d", ret);
         pn512_anticollision_callback(pPN512, ret);
         return;
     }
 
-  if( buffer_reader_readable(pResp) != 1 )
+    if (buffer_reader_readable(pResp) != 1) {
-  {
         NFC_WARN("Wrong length");
         pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
         return;
@@ -469,16 +422,13 @@ static void pn512_initiator_isoa_anticollision_cascade_3(pn512_t* pPN512, nfc_er
     NFC_DBG("Got SAK %02X", pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.sak);
 
     //Check SAK
-  if( pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.sak & 0x04 )
+    if (pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.sak & 0x04) {
-  {
         //Continue anticollision
         pPN512->anticollision.iso_a.cascade_level++;
         pPN512->anticollision.iso_a.valid_bits = 0;
         memset(pPN512->anticollision.iso_a.cln, 0, 5);
         pn512_initiator_isoa_anticollision_cascade_1(pPN512);
-  }
+    } else {
-  else
-  {
         //Anticollision complete
 
         NFC_DBG("Found one target- SAK = %02X", pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.sak);
@@ -486,18 +436,15 @@ static void pn512_initiator_isoa_anticollision_cascade_3(pn512_t* pPN512, nfc_er
         //Analyze SAK
         memset(&pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type, 0, sizeof(nfc_tech_t));
 
-    if( pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.sak & 0x40 ) //NFC-IP1 compliant
+        if (pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.sak & 0x40) { //NFC-IP1 compliant
-    {
             pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type.nfc_nfc_dep_a = true;
         }
         if ((pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.sak & 0x20)
-        && pPN512->config.initiators.nfc_iso_dep_a ) //ISO-14443A-4 compliant
+                && pPN512->config.initiators.nfc_iso_dep_a) { //ISO-14443A-4 compliant
-    {
             pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type.nfc_iso_dep_a = true;
         }
         if (!(pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcA.sak & 0x60)
-        && pPN512->config.initiators.nfc_type2 ) //Potentially NFC Type 2 (or Mifare, etc)
+                && pPN512->config.initiators.nfc_type2) { //Potentially NFC Type 2 (or Mifare, etc)
-    {
             pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type.nfc_type2 = true;
         }
 
@@ -505,8 +452,7 @@ static void pn512_initiator_isoa_anticollision_cascade_3(pn512_t* pPN512, nfc_er
         if (!pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type.nfc_iso_dep_a
                 && !pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type.nfc_nfc_dep_a
                 && !pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type.nfc_type2
-        )
+           ) {
-    {
             pn512_anticollision_callback(pPN512, NFC_ERR_NOPEER);
             return;
         }
@@ -517,8 +463,7 @@ static void pn512_initiator_isoa_anticollision_cascade_3(pn512_t* pPN512, nfc_er
 
         if (!pPN512->config.options.bail_at_first_target
                 && pPN512->anticollision.iso_a.more_targets
-        && (pPN512->transceiver.remote_targets_count < MUNFC_MAX_REMOTE_TARGETS) )
+                && (pPN512->transceiver.remote_targets_count < MUNFC_MAX_REMOTE_TARGETS)) {
-    {
             // Halt target and continue with others
             buffer_builder_t *pDataOutBldr = &pPN512->readBufBldr;
             buffer_builder_reset(pDataOutBldr);
@@ -541,8 +486,7 @@ static void pn512_initiator_isoa_anticollision_cascade_3(pn512_t* pPN512, nfc_er
 
 static void pn512_initiator_isoa_anticollision_cascade_4(pn512_t *pPN512, nfc_err_t ret)
 {
-  if(ret)
+    if (ret) {
-  {
         NFC_WARN("Could not halt device: error %d", ret);
         pn512_anticollision_callback(pPN512, ret);
         return;
@@ -586,22 +530,18 @@ void pn512_initiator_isob_anticollision_reqb(pn512_t* pPN512)
     buffer_builder_t *pDataOutBldr = &pPN512->readBufBldr;
     buffer_builder_reset(pDataOutBldr);
 
-  if (pPN512->anticollision.iso_b.slot_number == 0)
+    if (pPN512->anticollision.iso_b.slot_number == 0) {
-  {
         // Send REQB/WUPB
         pPN512->anticollision.iso_b.more_targets = false;
 
         buffer_builder_write_nu8(pDataOutBldr, REQB);
         buffer_builder_write_nu8(pDataOutBldr, 0x00); // AFI: All card types should respond
         uint8_t wup = 0;
-    if( (pPN512->anticollision.iso_b.slots_num_exponent == 0) ) //&& (pPN512->anticollision.iso_b.slot_number == 0))
+        if ((pPN512->anticollision.iso_b.slots_num_exponent == 0)) { //&& (pPN512->anticollision.iso_b.slot_number == 0))
-    {
             wup |= 0x8; // Send Wake-Up command on first iteration
         }
         buffer_builder_write_nu8(pDataOutBldr, wup | (pPN512->anticollision.iso_b.slots_num_exponent & 0x7)); // Param: number of slots
-  }
+    } else {
-  else
-  {
         // Just send slot marker
         buffer_builder_write_nu8(pDataOutBldr, REQB | ((pPN512->anticollision.iso_b.slot_number & 0xf) << 4));
     }
@@ -620,8 +560,7 @@ void pn512_initiator_isob_anticollision_atqb(pn512_t* pPN512, nfc_err_t ret)
     // - Collision --> check next slot number but we will have to increment number of slots
     buffer_t *pResp = pn512_get_read((nfc_transceiver_t *)pPN512);
 
-  if (ret && ( ret != NFC_ERR_COLLISION ) && ( ret != NFC_ERR_WRONG_COMM ) && ( ret != NFC_ERR_TIMEOUT ))
+    if (ret && (ret != NFC_ERR_COLLISION) && (ret != NFC_ERR_WRONG_COMM) && (ret != NFC_ERR_TIMEOUT)) {
-  {
         NFC_WARN("Did not receive ATQB: error %u", ret);
         pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
         return;
@@ -630,17 +569,13 @@ void pn512_initiator_isob_anticollision_atqb(pn512_t* pPN512, nfc_err_t ret)
     // Increment slot number
     pPN512->anticollision.iso_b.slot_number++;
 
-  if( (ret == NFC_ERR_COLLISION) || (ret == NFC_ERR_WRONG_COMM) )
+    if ((ret == NFC_ERR_COLLISION) || (ret == NFC_ERR_WRONG_COMM)) {
-  {
         pPN512->anticollision.iso_b.more_targets = true;
-  }
+    } else if (!ret) {
-  else if( !ret )
-  {
         pPN512->anticollision.iso_b.found_one = true;
 
         // Decode ATQB
-    if (buffer_reader_readable(pResp) != 12)
+        if (buffer_reader_readable(pResp) != 12) {
-    {
             NFC_WARN("Wrong length (%u bytes)", buffer_reader_readable(pResp));
             pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
             return;
@@ -651,8 +586,7 @@ void pn512_initiator_isob_anticollision_atqb(pn512_t* pPN512, nfc_err_t ret)
 
         // Check first byte
         uint8_t atqb0 = buffer_read_nu8(pResp);
-    if (atqb0 != 0x50)
+        if (atqb0 != 0x50) {
-    {
             NFC_WARN("Wrong first byte for ATQB: %02X", atqb0);
             pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
             return;
@@ -672,8 +606,7 @@ void pn512_initiator_isob_anticollision_atqb(pn512_t* pPN512, nfc_err_t ret)
 
         if (!pPN512->config.options.bail_at_first_target
                 && (pPN512->anticollision.iso_b.more_targets || (pPN512->anticollision.iso_b.slot_number < (1 << pPN512->anticollision.iso_b.slots_num_exponent)))
-        && (pPN512->transceiver.remote_targets_count < MUNFC_MAX_REMOTE_TARGETS) )
+                && (pPN512->transceiver.remote_targets_count < MUNFC_MAX_REMOTE_TARGETS)) {
-    {
             // Halt target and continue with others
             buffer_builder_t *pDataOutBldr = &pPN512->readBufBldr;
             buffer_builder_reset(pDataOutBldr);
@@ -689,9 +622,7 @@ void pn512_initiator_isob_anticollision_atqb(pn512_t* pPN512, nfc_err_t ret)
             pn512_set_write((nfc_transceiver_t *)pPN512, buffer_builder_buffer(pDataOutBldr));
             pn512_transceive_hw(pPN512, pn512_transceive_mode_transceive, pn512_initiator_isob_anticollision_haltb_resp);
             return;
-    }
+        } else {
-    else
-    {
             pn512_initiator_isob_anticollision_complete(pPN512);
             return;
         }
@@ -703,16 +634,13 @@ void pn512_initiator_isob_anticollision_atqb(pn512_t* pPN512, nfc_err_t ret)
 
 void pn512_initiator_isob_anticollision_next_slot(pn512_t *pPN512)
 {
-  if( pPN512->anticollision.iso_b.slot_number >= (1 << pPN512->anticollision.iso_b.slots_num_exponent))
+    if (pPN512->anticollision.iso_b.slot_number >= (1 << pPN512->anticollision.iso_b.slots_num_exponent)) {
-  {
+        if (!pPN512->anticollision.iso_b.more_targets) {
-    if(!pPN512->anticollision.iso_b.more_targets)
-    {
             // No further collisions to resolve
             pn512_initiator_isob_anticollision_complete(pPN512);
             return;
         }
-    if(pPN512->anticollision.iso_b.slots_num_exponent >= 4)
+        if (pPN512->anticollision.iso_b.slots_num_exponent >= 4) {
-    {
             // Cannot handle more than 16 slots
             pn512_initiator_isob_anticollision_complete(pPN512);
             return;
@@ -726,8 +654,7 @@ void pn512_initiator_isob_anticollision_next_slot(pn512_t* pPN512)
 void pn512_initiator_isob_anticollision_haltb_resp(pn512_t *pPN512, nfc_err_t ret)
 {
     // Check for response
-  if (ret)
+    if (ret) {
-  {
         NFC_WARN("Did not receive HALTB response: error %u", ret);
         pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
         return;
@@ -735,8 +662,7 @@ void pn512_initiator_isob_anticollision_haltb_resp(pn512_t* pPN512, nfc_err_t re
 
     buffer_t *pResp = pn512_get_read((nfc_transceiver_t *)pPN512);
 
-  if (buffer_reader_readable(pResp) != 1)
+    if (buffer_reader_readable(pResp) != 1) {
-  {
         NFC_WARN("Wrong length (%u bytes)", buffer_reader_readable(pResp));
         pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
         return;
@@ -747,8 +673,7 @@ void pn512_initiator_isob_anticollision_haltb_resp(pn512_t* pPN512, nfc_err_t re
 
     // Check byte
     uint8_t haltbr = buffer_read_nu8(pResp);
-  if (haltbr != 0x00)
+    if (haltbr != 0x00) {
-  {
         NFC_WARN("Wrong byte for HALTB response: %02X", haltbr);
         pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
         return;
@@ -760,12 +685,9 @@ void pn512_initiator_isob_anticollision_haltb_resp(pn512_t* pPN512, nfc_err_t re
 
 void pn512_initiator_isob_anticollision_complete(pn512_t *pPN512)
 {
-  if(pPN512->anticollision.iso_b.found_one)
+    if (pPN512->anticollision.iso_b.found_one) {
-  {
         pn512_anticollision_callback(pPN512, NFC_OK);
-  }
+    } else {
-  else
-  {
         pn512_anticollision_callback(pPN512, NFC_ERR_NOPEER);
     }
 }
@@ -812,8 +734,7 @@ void pn512_initiator_felica_anticollision_atqc(pn512_t* pPN512, nfc_err_t ret)
 {
     buffer_t *pResp = pn512_get_read((nfc_transceiver_t *)pPN512);
 
-  if (ret || (buffer_reader_readable(pResp) == 0))
+    if (ret || (buffer_reader_readable(pResp) == 0)) {
-  {
         NFC_WARN("Did not receive ATQC: error %d", ret);
         pn512_anticollision_callback(pPN512, NFC_ERR_NOPEER);
         return;
@@ -823,10 +744,8 @@ void pn512_initiator_felica_anticollision_atqc(pn512_t* pPN512, nfc_err_t ret)
     NFC_DBG("Got ATQC:");
     DBG_BLOCK(buffer_dump(pResp);)
 
-  while (buffer_reader_readable(pResp) > 0)
+    while (buffer_reader_readable(pResp) > 0) {
-  {
+        if (buffer_reader_readable(pResp) != 18 + 1) { // ATQC is 18 bytes, 1 byte for errors added by PN512
-    if (buffer_reader_readable(pResp) != 18 + 1) // ATQC is 18 bytes, 1 byte for errors added by PN512
-    {
             NFC_WARN("Wrong length (%d bytes)", buffer_reader_readable(pResp));
             pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
             return;
@@ -835,8 +754,7 @@ void pn512_initiator_felica_anticollision_atqc(pn512_t* pPN512, nfc_err_t ret)
         // First byte is length, check that it's correct
         uint8_t frame_length = buffer_read_nu8(pResp);
         uint8_t atqc0 = buffer_read_nu8(pResp);
-    if( (frame_length != 18) || (atqc0 != 0x01) )
+        if ((frame_length != 18) || (atqc0 != 0x01)) {
-    {
             NFC_WARN("Wrong ATQC frame");
             pn512_anticollision_callback(pPN512, NFC_ERR_PROTOCOL);
             return;
@@ -850,8 +768,7 @@ void pn512_initiator_felica_anticollision_atqc(pn512_t* pPN512, nfc_err_t ret)
 
         // Read error register
         uint8_t err_reg = buffer_read_nu8(pResp);
-    if(err_reg & 0x1f)
+        if (err_reg & 0x1f) {
-    {
             // Error within this time slot, skip
             continue;
         }
@@ -861,13 +778,10 @@ void pn512_initiator_felica_anticollision_atqc(pn512_t* pPN512, nfc_err_t ret)
         if (
             (pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcF.nfcid2[0] == 0x01)
             && (pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].nfcF.nfcid2[1] == 0xFE)
-        )
+        ) {
-    {
             // NFC-DEP supported
             pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type.nfc_nfc_dep_f_212 = 1;
-    }
+        } else {
-    else
-    {
             // Type 3 supported
             pPN512->transceiver.remote_targets[pPN512->transceiver.remote_targets_count].type.nfc_type3 = 1;
         }
@@ -876,8 +790,7 @@ void pn512_initiator_felica_anticollision_atqc(pn512_t* pPN512, nfc_err_t ret)
 
         // Only continue if we can have more targets
         if (!pPN512->config.options.bail_at_first_target
-        && (pPN512->transceiver.remote_targets_count < MUNFC_MAX_REMOTE_TARGETS) )
+                && (pPN512->transceiver.remote_targets_count < MUNFC_MAX_REMOTE_TARGETS)) {
-    {
             continue;
         }
         break;
@@ -909,8 +822,7 @@ void pn512_poll_setup(pn512_t* pPN512)
 //      || pPN512->config.initiators.nfc_nfc_dep_f_212
 //      || pPN512->config.initiators.nfc_nfc_dep_f_424;
 
-  if (target)
+    if (target) {
-  {
         NFC_DBG("Configure anticoll/polling response");
         //Setup ATQA, SAK and Felica polling response
         pn512_fifo_clear(pPN512);
@@ -923,42 +835,33 @@ void pn512_poll_setup(pn512_t* pPN512)
         buffer_builder_write_nu8(pDataCfgBldr, 0x00);
 
         //Write NFCID1 (0s as it will be randomly generated) - first byte will be set to 0x08 by HW according to NFC-IP1
-    for (int i = 0; i < 3; i++)
+        for (int i = 0; i < 3; i++) {
-    {
             buffer_builder_write_nu8(pDataCfgBldr, 0x00);
         }
 
         //Write SAK
         uint8_t sak = 0x00; //Default SAK (UID complete)
-    if (pPN512->config.targets.nfc_iso_dep_a)
+        if (pPN512->config.targets.nfc_iso_dep_a) {
-    {
             sak |= 0x20; //This target is ISO-14443A-4 compliant
         }
-    if (pPN512->config.targets.nfc_nfc_dep_a)
+        if (pPN512->config.targets.nfc_nfc_dep_a) {
-    {
             sak |= 0x40; //This target is NFC-IP1 compliant
         }
         buffer_builder_write_nu8(pDataCfgBldr, sak);
 
         //Write NFCID2 (xx 0xfe according to NFC-IP1 and 0s as 6 bytes will be randomly generated)
-    if (pPN512->config.targets.nfc_nfc_dep_f_212 || pPN512->config.targets.nfc_nfc_dep_f_424)
+        if (pPN512->config.targets.nfc_nfc_dep_f_212 || pPN512->config.targets.nfc_nfc_dep_f_424) {
-    {
             //Byte 1 is 0x01 if supporting NFC-IP1
             buffer_builder_write_nu8(pDataCfgBldr, 0x01);
-    }
+        } else if (pPN512->config.targets.nfc_type3) { //NFC-IP will have priority over type 3 tag emulation
-    else if (pPN512->config.targets.nfc_type3) //NFC-IP will have priority over type 3 tag emulation
-    {
             //Byte 1 is 0x02 if supporting Type 3 tag platform
             buffer_builder_write_nu8(pDataCfgBldr, 0x02);
-    }
+        } else {
-    else
-    {
             buffer_builder_write_nu8(pDataCfgBldr, 0x00);
         }
         buffer_builder_write_nu8(pDataCfgBldr, 0xFE);
 
-    for (int i = 0; i < 6; i++)
+        for (int i = 0; i < 6; i++) {
-    {
             buffer_builder_write_nu8(pDataCfgBldr, 0x00);
         }
 
@@ -972,13 +875,10 @@ void pn512_poll_setup(pn512_t* pPN512)
         buffer_builder_write_nu8(pDataCfgBldr, 0x00);
 
         if (!(pPN512->config.targets.nfc_nfc_dep_f_212 || pPN512->config.targets.nfc_nfc_dep_f_424)
-        && pPN512->config.targets.nfc_type3)
+                && pPN512->config.targets.nfc_type3) {
-    {
             buffer_builder_write_nu8(pDataCfgBldr, 0x01); //MRTI Check
             buffer_builder_write_nu8(pDataCfgBldr, 0x01); //MRTI Update
-    }
+        } else {
-    else
-    {
             buffer_builder_write_nu8(pDataCfgBldr, 0x00);
             buffer_builder_write_nu8(pDataCfgBldr, 0x00);
         }
@@ -988,13 +888,10 @@ void pn512_poll_setup(pn512_t* pPN512)
 
         //2 system code bytes
         if (!(pPN512->config.targets.nfc_nfc_dep_f_212 || pPN512->config.targets.nfc_nfc_dep_f_424)
-        && pPN512->config.targets.nfc_type3)
+                && pPN512->config.targets.nfc_type3) {
-    {
             buffer_builder_write_nu8(pDataCfgBldr, 0x12);
             buffer_builder_write_nu8(pDataCfgBldr, 0xFC);
-    }
+        } else {
-    else
-    {
             buffer_builder_write_nu8(pDataCfgBldr, 0xFF); //Wildcard system code
             buffer_builder_write_nu8(pDataCfgBldr, 0xFF);
         }
@@ -1020,8 +917,7 @@ static void pn512_poll_delay_complete(uint32_t events, void* pUserData)
 {
     pn512_t *pPN512 = (pn512_t *) pUserData;
 
-  if(events & EVENT_ABORTED)
+    if (events & EVENT_ABORTED) {
-  {
         pn512_poll_callback(pPN512, NFC_ERR_ABORTED);
         return;
     }
@@ -1038,12 +934,10 @@ static void pn512_poll_delay(pn512_t* pPN512, uint32_t timeout)
 void pn512_poll_iteration(pn512_t *pPN512, nfc_err_t ret)
 {
     do {
-    if( pPN512->poll.state == pn512_polling_state_start_listening )
+        if (pPN512->poll.state == pn512_polling_state_start_listening) {
-    {
             NFC_DBG("pn512_polling_state_start_listening");
             // Start with listening
-      if( !pn512_config_target(pPN512) )
+            if (!pn512_config_target(pPN512)) {
-      {
                 // Otherwise switch to next step
                 pPN512->poll.state = pn512_polling_state_start_polling;
                 continue;
@@ -1067,16 +961,11 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             NFC_DBG("Switch in target mode and set framing: ISO A: %s; Felica: %s", iso14443a ? "Yes" : "No", felica ? "Yes" : "No");
 
             //Switch in target mode
-      if(iso14443a && felica)
+            if (iso14443a && felica) {
-      {
                 pn512_framing_set(pPN512, nfc_framing_target_mode_detector);
-      }
+            } else if (iso14443a) {
-      else if(iso14443a)
-      {
                 pn512_framing_set(pPN512, nfc_framing_target_a_106);
-      }
+            } else if (felica) {
-      else if(felica)
-      {
                 pn512_framing_set(pPN512, nfc_framing_target_f_212);
             }
 
@@ -1084,26 +973,22 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_listen_wait_for_remote_field )
+        if (pPN512->poll.state == pn512_polling_state_listen_wait_for_remote_field) {
-    {
             NFC_DBG("pn512_polling_state_listen_wait_for_remote_field");
 
-      if( !pn512_config_target(pPN512) )
+            if (!pn512_config_target(pPN512)) {
-      {
                 // Otherwise switch to next step
                 pPN512->poll.state = pn512_polling_state_start_listening;
                 continue;
             }
 
-      if( ret == NFC_ERR_TIMEOUT )
+            if (ret == NFC_ERR_TIMEOUT) {
-      {
                 // Continue polling
                 pPN512->poll.state = pn512_polling_state_start_polling;
                 continue;
             }
 
-      if(ret)
+            if (ret) {
-      {
                 pn512_poll_callback(pPN512, ret);
                 return;
             }
@@ -1114,12 +999,10 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_listen_anticollision )
+        if (pPN512->poll.state == pn512_polling_state_listen_anticollision) {
-    {
             NFC_DBG("pn512_polling_state_listen_anticollision");
 
-      if(ret == NFC_ERR_FIELD)
+            if (ret == NFC_ERR_FIELD) {
-      {
                 // This means that a remote field was dropped - give it another chance
                 pPN512->poll.state = pn512_polling_state_listen_wait_for_remote_field;
                 pn512_rf_field_switch_off(pPN512);
@@ -1127,8 +1010,7 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
                 return;
             }
 
-      if(ret)
+            if (ret) {
-      {
                 pn512_poll_callback(pPN512, ret);
                 return;
             }
@@ -1140,12 +1022,10 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_start_polling )
+        if (pPN512->poll.state == pn512_polling_state_start_polling) {
-    {
             NFC_DBG("pn512_polling_state_start_polling");
 
-      if( !pn512_config_initiator(pPN512) )
+            if (!pn512_config_initiator(pPN512)) {
-      {
                 // Otherwise switch to next step
                 pPN512->poll.state = pn512_polling_state_start_listening;
                 continue;
@@ -1158,20 +1038,17 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_rf_collision_avoidance)
+        if (pPN512->poll.state == pn512_polling_state_rf_collision_avoidance) {
-    {
             NFC_DBG("pn512_polling_state_rf_collision_avoidance");
 
-      if(ret)
+            if (ret) {
-      {
                 pn512_poll_callback(pPN512, ret);
                 return;
             }
 
             NFC_DBG("Own RF field is %s", pPN512->rf_on ? "on" : "off");
 
-      if(!pPN512->rf_on)
+            if (!pPN512->rf_on) {
-      {
                 // Go back to listening, target framing is still valid so no need to reset it
                 pPN512->poll.state = pn512_polling_state_listen_wait_for_remote_field;
                 continue;
@@ -1180,14 +1057,12 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             pPN512->poll.state = pn512_polling_state_polling_nfc_a_start;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_polling_nfc_a_start )
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_a_start) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_a_start");
 
             //Check if ISO A is needed
             bool nfc_a = pPN512->config.initiators.nfc_type2 || pPN512->config.initiators.nfc_iso_dep_a || pPN512->config.initiators.nfc_nfc_dep_a; //We do not support type 1 card emulation so irrelevant
-      if(!nfc_a)
+            if (!nfc_a) {
-      {
                 // Continue with NFC B
                 pPN512->poll.state = pn512_polling_state_polling_nfc_b_start;
                 continue;
@@ -1201,8 +1076,7 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_polling_nfc_a_gt )
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_a_gt) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_a_gt");
 
             // Start anticollision
@@ -1211,27 +1085,23 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_polling_nfc_a_anticollision )
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_a_anticollision) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_a_anticollision");
 
-      if( ret == NFC_ERR_NOPEER )
+            if (ret == NFC_ERR_NOPEER) {
-      {
                 NFC_DBG("Not found");
                 // Continue with NFC B
                 pPN512->poll.state = pn512_polling_state_polling_nfc_b_start;
                 continue;
             }
 
-      if( (ret == NFC_OK) && (pPN512->config.options.bail_at_first_tech || (pPN512->transceiver.remote_targets_count == MUNFC_MAX_REMOTE_TARGETS)) )
+            if ((ret == NFC_OK) && (pPN512->config.options.bail_at_first_tech || (pPN512->transceiver.remote_targets_count == MUNFC_MAX_REMOTE_TARGETS))) {
-      {
                 // At least one target found, exit polling loop
                 pn512_poll_callback(pPN512, NFC_OK);
                 return;
             }
 
-      if( ret == NFC_ERR_ABORTED )
+            if (ret == NFC_ERR_ABORTED) {
-      {
                 pn512_poll_callback(pPN512, ret);
                 return;
             }
@@ -1241,14 +1111,12 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             continue;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_polling_nfc_b_start )
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_b_start) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_b_start");
 
             //Check if ISO B is needed
             bool nfc_b = pPN512->config.initiators.nfc_iso_dep_b;
-      if (!nfc_b)
+            if (!nfc_b) {
-      {
                 // Continue with NFC F
                 pPN512->poll.state = pn512_polling_state_polling_nfc_f_start;
                 continue;
@@ -1262,8 +1130,7 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if (pPN512->poll.state == pn512_polling_state_polling_nfc_b_gt)
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_b_gt) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_b_gt");
 
             // Start anticollision
@@ -1272,12 +1139,10 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if (pPN512->poll.state == pn512_polling_state_polling_nfc_b_anticollision)
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_b_anticollision) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_b_anticollision");
 
-      if (ret == NFC_ERR_NOPEER)
+            if (ret == NFC_ERR_NOPEER) {
-      {
                 NFC_DBG("Not found");
                 // Continue with NFC F
                 pPN512->poll.state = pn512_polling_state_polling_nfc_f_start;
@@ -1287,15 +1152,13 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             if ((ret == NFC_OK)
                     && (pPN512->config.options.bail_at_first_tech
                         || (pPN512->transceiver.remote_targets_count
-                  == MUNFC_MAX_REMOTE_TARGETS)))
+                            == MUNFC_MAX_REMOTE_TARGETS))) {
-      {
                 // At least one target found, exit polling loop
                 pn512_poll_callback(pPN512, NFC_OK);
                 return;
             }
 
-      if( ret == NFC_ERR_ABORTED )
+            if (ret == NFC_ERR_ABORTED) {
-      {
                 pn512_poll_callback(pPN512, ret);
                 return;
             }
@@ -1305,14 +1168,12 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             continue;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_polling_nfc_f_start )
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_f_start) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_f_start");
 
             //Check if Felica is needed
             bool nfc_f = pPN512->config.initiators.nfc_type3 || pPN512->config.initiators.nfc_nfc_dep_f_212;
-      if(!nfc_f)
+            if (!nfc_f) {
-      {
                 // Wrap up
                 pPN512->poll.state = pn512_polling_state_finish_polling;
                 continue;
@@ -1326,8 +1187,7 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_polling_nfc_f_gt )
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_f_gt) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_f_gt");
 
             // Start anticollision
@@ -1336,27 +1196,23 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             return;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_polling_nfc_f_anticollision )
+        if (pPN512->poll.state == pn512_polling_state_polling_nfc_f_anticollision) {
-    {
             NFC_DBG("pn512_polling_state_polling_nfc_f_anticollision");
 
-      if( ret == NFC_ERR_NOPEER )
+            if (ret == NFC_ERR_NOPEER) {
-      {
                 NFC_DBG("Not found");
                 // Resolve polling
                 pPN512->poll.state = pn512_polling_state_finish_polling;
                 continue;
             }
 
-      if( (ret == NFC_OK) && (pPN512->config.options.bail_at_first_tech || (pPN512->transceiver.remote_targets_count == MUNFC_MAX_REMOTE_TARGETS)) )
+            if ((ret == NFC_OK) && (pPN512->config.options.bail_at_first_tech || (pPN512->transceiver.remote_targets_count == MUNFC_MAX_REMOTE_TARGETS))) {
-      {
                 // At least one target found, exit polling loop
                 pn512_poll_callback(pPN512, NFC_OK);
                 return;
             }
 
-      if( ret == NFC_ERR_ABORTED )
+            if (ret == NFC_ERR_ABORTED) {
-      {
                 pn512_poll_callback(pPN512, ret);
                 return;
             }
@@ -1366,14 +1222,10 @@ void pn512_poll_iteration(pn512_t* pPN512, nfc_err_t ret)
             continue;
         }
 
-    if( pPN512->poll.state == pn512_polling_state_finish_polling )
+        if (pPN512->poll.state == pn512_polling_state_finish_polling) {
-    {
+            if (pPN512->transceiver.remote_targets_count > 0) {
-      if(pPN512->transceiver.remote_targets_count > 0)
-      {
                 pn512_poll_callback(pPN512, NFC_OK);
-      }
+            } else {
-      else
-      {
                 pn512_poll_callback(pPN512, NFC_ERR_NOPEER);
             }
             return;
@@ -1398,8 +1250,7 @@ void pn512_poll_hw(pn512_t* pPN512, pn512_cb_t cb)
     //Initialize state machine
     pPN512->poll.state = pn512_polling_state_start_listening;
 
-  if( !pn512_config_target(pPN512) && !pn512_config_initiator(pPN512) )
+    if (!pn512_config_target(pPN512) && !pn512_config_initiator(pPN512)) {
-  {
         pn512_poll_callback(pPN512, NFC_ERR_PARAMS);
         return;
     }

features/nfc/stack/transceiver/pn512/pn512_registers.c

@@ -83,8 +83,7 @@ static const uint8_t PN512_CFG_INIT_VALS[] = {
 void pn512_registers_reset(pn512_t *pPN512)
 {
     pn512_register_switch_page_intl(pPN512, 0);
-  for(int i = 0; i < PN512_CFG_INIT_LEN; i++)
+    for (int i = 0; i < PN512_CFG_INIT_LEN; i++) {
-  {
         pn512_register_write(pPN512, PN512_CFG_INIT_REGS[i], PN512_CFG_INIT_VALS[i]);
     }
 }
@@ -97,8 +96,7 @@ void pn512_registers_reset(pn512_t* pPN512)
 void pn512_register_write(pn512_t *pPN512, uint8_t address, uint8_t data)
 {
     NFC_DBG("Write [%02x] << %02x", address, data);
-  if(REGISTER_PAGE(address) != pPN512->registers.registers_page)
+    if (REGISTER_PAGE(address) != pPN512->registers.registers_page) {
-  {
         pn512_register_switch_page_intl(pPN512, REGISTER_PAGE(address));
     }
     address = REGISTER_ADDR(address);
@@ -117,8 +115,7 @@ uint8_t pn512_register_read(pn512_t* pPN512, uint8_t address)
         uint8_t __dbg_addr;
         __dbg_addr = address; //FIXME
     )
-  if(REGISTER_PAGE(address) != pPN512->registers.registers_page)
+    if (REGISTER_PAGE(address) != pPN512->registers.registers_page) {
-  {
         pn512_register_switch_page_intl(pPN512, REGISTER_PAGE(address));
     }
     address = REGISTER_ADDR(address);
@@ -129,8 +126,7 @@ uint8_t pn512_register_read(pn512_t* pPN512, uint8_t address)
 
 void pn512_register_switch_page(pn512_t *pPN512, uint8_t address)
 {
-  if(REGISTER_PAGE(address) != pPN512->registers.registers_page)
+    if (REGISTER_PAGE(address) != pPN512->registers.registers_page) {
-  {
         pn512_register_switch_page_intl(pPN512, REGISTER_PAGE(address));
     }
 }

features/nfc/stack/transceiver/pn512/pn512_rf.c

@@ -48,16 +48,14 @@ static const uint8_t framing_registers_felica_414k[] = { 0x3A, 0xA2, 0xA2, 0x12,
 
 nfc_err_t pn512_framing_set(pn512_t *pPN512, nfc_framing_t framing)
 {
-  if(framing == pPN512->framing) //No need to do anything
+    if (framing == pPN512->framing) { //No need to do anything
-  {
         return NFC_OK;
     }
 
     NFC_DBG("Switching to %u", framing);
 
     const uint8_t *framing_registers_values;
-  switch(framing)
+    switch (framing) {
-  {
         case nfc_framing_target_mode_detector:
             framing_registers_values = framing_registers_mode_detector;
             break;
@@ -82,8 +80,7 @@ nfc_err_t pn512_framing_set(pn512_t* pPN512, nfc_framing_t framing)
             return NFC_ERR_UNSUPPORTED;
     }
 
-  for(int i = 0; i < PN512_FRAMING_REGS; i++)
+    for (int i = 0; i < PN512_FRAMING_REGS; i++) {
-  {
         pn512_register_write(pPN512, framing_registers[i], framing_registers_values[i]);
     }
 
@@ -93,8 +90,7 @@ nfc_err_t pn512_framing_set(pn512_t* pPN512, nfc_framing_t framing)
 
     //TODO initiator: PN512_REG_MODGSP
 
-  switch(pPN512->framing)
+    switch (pPN512->framing) {
-  {
         case nfc_framing_initiator_a_106:
         case nfc_framing_initiator_b_106:
         case nfc_framing_initiator_f_212:
@@ -111,13 +107,10 @@ nfc_err_t pn512_framing_set(pn512_t* pPN512, nfc_framing_t framing)
             return NFC_ERR_UNSUPPORTED;
     }
 #if 1
-  if( (pPN512->framing == nfc_framing_initiator_a_106) /*|| (pPN512->framing == pn512_framing_target_iso14443a_106k)*/ )
+    if ((pPN512->framing == nfc_framing_initiator_a_106) /*|| (pPN512->framing == pn512_framing_target_iso14443a_106k)*/) {
-  {
         //Enable 100% ASK Modulation
         pn512_register_write(pPN512, PN512_REG_TXAUTO, pn512_register_read(pPN512, PN512_REG_TXAUTO) | 0x40);
-  }
+    } else {
-  else
-  {
         pn512_register_write(pPN512, PN512_REG_TXAUTO, pn512_register_read(pPN512, PN512_REG_TXAUTO) & (~0x40));
     }
 #endif
@@ -127,8 +120,7 @@ nfc_err_t pn512_framing_set(pn512_t* pPN512, nfc_framing_t framing)
 nfc_err_t pn512_framing_crc_set(pn512_t *pPN512, bool out, bool in)
 {
     const uint8_t *framing_registers_values;
-  switch(pPN512->framing)
+    switch (pPN512->framing) {
-  {
         case nfc_framing_target_mode_detector:
             framing_registers_values = framing_registers_mode_detector;
             break;
@@ -153,13 +145,11 @@ nfc_err_t pn512_framing_crc_set(pn512_t* pPN512, bool out, bool in)
             return NFC_ERR_UNSUPPORTED;
     }
 
-  if(pPN512->crc.out != out)
+    if (pPN512->crc.out != out) {
-  {
         pn512_register_write(pPN512, framing_registers[1], (framing_registers_values[1] & 0x7F) | (out ? 0x80 : 0x00)); //TXMODE
         pPN512->crc.out = out;
     }
-  if(pPN512->crc.in != in)
+    if (pPN512->crc.in != in) {
-  {
         pn512_register_write(pPN512, framing_registers[2], (framing_registers_values[2] & 0x7F) | (in ? 0x80 : 0x00)); //RXMODE
         pPN512->crc.in = in;
     }
@@ -170,8 +160,7 @@ nfc_err_t pn512_framing_crc_set(pn512_t* pPN512, bool out, bool in)
 nfc_err_t pn512_framing_rx_multiple_enable(pn512_t *pPN512)
 {
     const uint8_t *framing_registers_values;
-  switch(pPN512->framing)
+    switch (pPN512->framing) {
-  {
         case nfc_framing_target_mode_detector:
             framing_registers_values = framing_registers_mode_detector;
             break;
@@ -221,8 +210,7 @@ void pn512_rf_field_nfcip1_rf_collision_avoidance_complete(uint32_t events, void
     pn512_irq_set(pPN512, PN512_IRQ_NONE);
     pn512_irq_clear(pPN512, PN512_IRQ_RF_ON | PN512_IRQ_TIMER);
 
-  if(irq_res & PN512_IRQ_RF_ON)
+    if (irq_res & PN512_IRQ_RF_ON) {
-  {
         NFC_DBG("External field on");
 
         //Clear TXAUTO register
@@ -234,8 +222,7 @@ void pn512_rf_field_nfcip1_rf_collision_avoidance_complete(uint32_t events, void
     }
 
     //Has our RF field been switched on?
-  if( pn512_register_read(pPN512, PN512_REG_TXAUTO) & 0x40 ) //InitialRFOn bit is cleared automatically, if the RF field is switched on
+    if (pn512_register_read(pPN512, PN512_REG_TXAUTO) & 0x40) { //InitialRFOn bit is cleared automatically, if the RF field is switched on
-  {
         NFC_ERR("InitialRFOn bit still set");
         pn512_rf_callback(pPN512, NFC_ERR_UNKNOWN);
         return;
@@ -262,8 +249,7 @@ void pn512_rf_field_nfcip1_rf_collision_avoidance(pn512_t* pPN512, pn512_cb_t cb
     pn512_register_write(pPN512, PN512_REG_TXAUTO, 0x0F);
 
     //Is external RF Field already on?
-  if( pn512_register_read(pPN512, PN512_REG_STATUS1) & 0x4 )
+    if (pn512_register_read(pPN512, PN512_REG_STATUS1) & 0x4) {
-  {
         NFC_DBG("External field already on");
         pPN512->rf_on = false; //External field on
 
@@ -293,14 +279,12 @@ void pn512_rf_field_wait_for_external_complete_task(uint32_t events, void* pUser
     pn512_irq_set(pPN512, PN512_IRQ_NONE);
     pn512_irq_clear(pPN512, PN512_IRQ_RF_ON);
 
-  if(events & EVENT_ABORTED)
+    if (events & EVENT_ABORTED) {
-  {
         pn512_rf_callback(pPN512, NFC_ERR_ABORTED);
         return;
     }
 
-  if( events & EVENT_TIMEOUT )
+    if (events & EVENT_TIMEOUT) {
-  {
         NFC_DBG("Timeout");
         pn512_rf_callback(pPN512, NFC_ERR_TIMEOUT);
         return;
@@ -320,8 +304,7 @@ void pn512_rf_field_wait_for_external(pn512_t* pPN512, int timeout, pn512_cb_t c
 
     //Is external RF Field already on?
     pn512_irq_set(pPN512, PN512_IRQ_RF_ON /* External field switched on */);
-  if( pn512_register_read(pPN512, PN512_REG_STATUS1) & 0x4 )
+    if (pn512_register_read(pPN512, PN512_REG_STATUS1) & 0x4) {
-  {
         NFC_DBG("RF field already on");
         pn512_irq_set(pPN512, PN512_IRQ_NONE);
         pn512_irq_clear(pPN512, PN512_IRQ_RF_ON);

features/nfc/stack/transceiver/pn512/pn512_timer.c

@@ -39,8 +39,7 @@ void pn512_timer_config(pn512_t* pPN512, bool autostart, uint16_t prescaler, uin
 void pn512_timer_start(pn512_t *pPN512)
 {
     //The control register also contains the initiator bit that we must set correctly
-  switch(pPN512->framing)
+    switch (pPN512->framing) {
-  {
         case nfc_framing_initiator_a_106:
         case nfc_framing_initiator_f_212:
         case nfc_framing_initiator_f_424:
@@ -59,8 +58,7 @@ void pn512_timer_start(pn512_t* pPN512)
 void pn512_timer_stop(pn512_t *pPN512)
 {
     //The control register also contains the initiator bit that we must set correctly
-  switch(pPN512->framing)
+    switch (pPN512->framing) {
-  {
         case nfc_framing_initiator_a_106:
         case nfc_framing_initiator_f_212:
         case nfc_framing_initiator_f_424:

features/nfc/stack/transceiver/pn512/pn512_transceive.c

@@ -42,25 +42,19 @@ void pn512_transceive_hw_tx_iteration(pn512_t* pPN512, bool start)
 {
     uint16_t irqs_en = pn512_irq_enabled(pPN512);
 
-  if( buffer_reader_readable(&pPN512->writeBuf) > 0 )
+    if (buffer_reader_readable(&pPN512->writeBuf) > 0) {
-  {
         //Fill FIFO
         pn512_fifo_write(pPN512, &pPN512->writeBuf);
 
-    if (buffer_reader_readable(&pPN512->writeBuf) > 0) //Did not fit in FIFO
+        if (buffer_reader_readable(&pPN512->writeBuf) > 0) { //Did not fit in FIFO
-    {
             pn512_irq_clear(pPN512, PN512_IRQ_LOW_ALERT);
             //Has low FIFO alert IRQ already been enabled?
-      if (!(irqs_en & PN512_IRQ_LOW_ALERT))
+            if (!(irqs_en & PN512_IRQ_LOW_ALERT)) {
-      {
                 irqs_en |= PN512_IRQ_LOW_ALERT;
                 pn512_irq_set(pPN512, irqs_en);
             }
-    }
+        } else {
-    else
+            if (irqs_en & PN512_IRQ_LOW_ALERT) {
-    {
-      if (irqs_en & PN512_IRQ_LOW_ALERT)
-      {
                 //Buffer has been fully sent
                 irqs_en &= ~PN512_IRQ_LOW_ALERT;
                 pn512_irq_set(pPN512, irqs_en);
@@ -69,19 +63,15 @@ void pn512_transceive_hw_tx_iteration(pn512_t* pPN512, bool start)
     }
 
 
-  if (start)
+    if (start) {
-  {
+        if ((pPN512->transceive.mode == pn512_transceive_mode_transmit) || (pPN512->transceive.mode == pn512_transceive_mode_transmit_and_target_autocoll)) {
-    if ( (pPN512->transceive.mode == pn512_transceive_mode_transmit) || (pPN512->transceive.mode == pn512_transceive_mode_transmit_and_target_autocoll) )
-    {
             //Update bitframing register
             pn512_register_write(pPN512, PN512_REG_BITFRAMING,
                                  0x00 | ((pPN512->readFirstByteAlign & 0x7) << 4) | (pPN512->writeLastByteLength & 0x7));
 
             //Use transmit command
             pn512_cmd_exec(pPN512, PN512_CMD_TRANSMIT);
-    }
+        } else {
-    else
-    {
             NFC_DBG("Bitframing %02X", 0x80 | ((pPN512->readFirstByteAlign & 0x7) << 4) | (pPN512->writeLastByteLength & 0x7));
             //Update bitframing register to start transmission
             pn512_register_write(pPN512, PN512_REG_BITFRAMING,
@@ -102,8 +92,7 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
 {
     pn512_t *pPN512 = (pn512_t *) pUserData;
 
-  if(events & EVENT_ABORTED)
+    if (events & EVENT_ABORTED) {
-  {
         //Stop command
         pn512_cmd_exec(pPN512, PN512_CMD_IDLE);
         pPN512->transceive.mode = pn512_transceive_mode_idle;
@@ -118,8 +107,7 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
     }
 
     NFC_DBG("TX task");
-  if(events & EVENT_TIMEOUT)
+    if (events & EVENT_TIMEOUT) {
-  {
         // Check status
         NFC_DBG("Status = %02X %02X", pn512_register_read(pPN512, PN512_REG_STATUS1), pn512_register_read(pPN512, PN512_REG_STATUS2));
 
@@ -140,8 +128,7 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
     uint16_t irqs_en = pn512_irq_enabled(pPN512);
     uint16_t irqs = pn512_irq_get(pPN512);
 
-  if( irqs & PN512_IRQ_RF_OFF )
+    if (irqs & PN512_IRQ_RF_OFF) {
-  {
         //Stop command
         pn512_cmd_exec(pPN512, PN512_CMD_IDLE);
         pPN512->transceive.mode = pn512_transceive_mode_idle;
@@ -152,10 +139,8 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
         pn512_transceive_callback(pPN512, NFC_ERR_FIELD);
         return;
     }
-  if( irqs & PN512_IRQ_TX )
+    if (irqs & PN512_IRQ_TX) {
-  {
+        if (irqs_en & PN512_IRQ_LOW_ALERT) {
-    if( irqs_en & PN512_IRQ_LOW_ALERT )
-    {
             //If the transmission has been completed without us getting a chance to fill the buffer up it means that we had a buffer underflow
             NFC_ERR("Buffer underflow");
             pn512_irq_set(pPN512, PN512_IRQ_NONE);
@@ -171,10 +156,8 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
 
         //Start receiving
         NFC_DBG("Transmission complete");
-    if(pPN512->transceive.mode != pn512_transceive_mode_transmit)
+        if (pPN512->transceive.mode != pn512_transceive_mode_transmit) {
-    {
+            if (pPN512->transceive.mode == pn512_transceive_mode_transmit_and_target_autocoll) {
-      if(pPN512->transceive.mode == pn512_transceive_mode_transmit_and_target_autocoll)
-      {
                 //Make sure bitframing reg is clean
                 pn512_register_write(pPN512, PN512_REG_BITFRAMING, 0x00);
 
@@ -183,15 +166,11 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
 
                 //Start autocoll
                 pn512_cmd_exec(pPN512, PN512_CMD_AUTOCOLL);
-      }
+            } else {
-      else
-      {
                 pn512_transceive_hw_rx_start(pPN512);
             }
             return;
-    }
+        } else {
-    else
-    {
             pn512_irq_set(pPN512, PN512_IRQ_NONE);
             pn512_irq_clear(pPN512, PN512_IRQ_RX | PN512_IRQ_HIGH_ALERT);
 
@@ -199,8 +178,7 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
             return;
         }
     }
-  if( (irqs & PN512_IRQ_LOW_ALERT) && (buffer_reader_readable(&pPN512->writeBuf) > 0) )
+    if ((irqs & PN512_IRQ_LOW_ALERT) && (buffer_reader_readable(&pPN512->writeBuf) > 0)) {
-  {
         //Continue to fill FIFO
         pn512_irq_clear(pPN512, PN512_IRQ_LOW_ALERT);
 
@@ -208,8 +186,7 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
         return;
     }
 
-  if( irqs & PN512_IRQ_IDLE )
+    if (irqs & PN512_IRQ_IDLE) {
-  {
         pn512_irq_clear(pPN512, PN512_IRQ_ERR);
 
         NFC_ERR("Modem went to idle");
@@ -230,8 +207,7 @@ void pn512_transceive_hw_tx_task(uint32_t events, void* pUserData)
 void pn512_transceive_hw_rx_start(pn512_t *pPN512)
 {
     uint16_t irqs_en = PN512_IRQ_RX | PN512_IRQ_HIGH_ALERT | PN512_IRQ_ERR;
-  if(PN512_FRAMING_IS_TARGET(pPN512->framing))
+    if (PN512_FRAMING_IS_TARGET(pPN512->framing)) {
-  {
         irqs_en |= PN512_IRQ_RF_OFF;
     }
 
@@ -252,8 +228,7 @@ void pn512_transceive_hw_rx_task(uint32_t events, void* pUserData)
     pn512_t *pPN512 = (pn512_t *) pUserData;
 
     NFC_DBG("RX task");
-  if(events & EVENT_ABORTED)
+    if (events & EVENT_ABORTED) {
-  {
         //Stop command
         pn512_cmd_exec(pPN512, PN512_CMD_IDLE);
         pPN512->transceive.mode = pn512_transceive_mode_idle;
@@ -267,8 +242,7 @@ void pn512_transceive_hw_rx_task(uint32_t events, void* pUserData)
         return;
     }
 
-  if(events & EVENT_TIMEOUT)
+    if (events & EVENT_TIMEOUT) {
-  {
         NFC_WARN("Timeout");
         //Stop command
         pn512_cmd_exec(pPN512, PN512_CMD_IDLE);
@@ -285,25 +259,20 @@ void pn512_transceive_hw_rx_task(uint32_t events, void* pUserData)
     uint16_t irqs = pn512_irq_get(pPN512);
     NFC_DBG("irqs %04x", irqs);
     bool collision_detected = false;
-  if( irqs & PN512_IRQ_ERR )
+    if (irqs & PN512_IRQ_ERR) {
-  {
         pn512_irq_clear(pPN512, PN512_IRQ_ERR);
 
         uint8_t err_reg = pn512_register_read(pPN512, PN512_REG_ERROR);
         NFC_ERR("Got error - error reg is %02X", err_reg);
         // if err_reg == 0, sticky error that must have been cleared automatically, continue
-    if( err_reg != 0 )
+        if (err_reg != 0) {
-    {
             //If it's a collsision, flag it but still carry on with RX procedure
             collision_detected = true;
 
-      if( (err_reg == 0x08) || (err_reg == 0x0A) ) // Collision (and maybe parity) (and no other error)
+            if ((err_reg == 0x08) || (err_reg == 0x0A)) { // Collision (and maybe parity) (and no other error)
-      {
                 irqs &= ~PN512_IRQ_ERR;
                 irqs |= PN512_IRQ_RX;
-      }
+            } else {
-      else
-      {
                 DBG_BLOCK(
                     //Empty FIFO into buffer
                     pn512_fifo_read(pPN512, &pPN512->readBufBldr);
@@ -328,13 +297,11 @@ void pn512_transceive_hw_rx_task(uint32_t events, void* pUserData)
             }
         }
     }
-  if( (irqs & PN512_IRQ_RX) || (irqs & PN512_IRQ_HIGH_ALERT) )
+    if ((irqs & PN512_IRQ_RX) || (irqs & PN512_IRQ_HIGH_ALERT)) {
-  {
         //Empty FIFO into buffer
         pn512_fifo_read(pPN512, &pPN512->readBufBldr);
 
-    if( (buffer_builder_writeable(&pPN512->readBufBldr) == 0) && (pn512_fifo_length(pPN512) > 0) )
+        if ((buffer_builder_writeable(&pPN512->readBufBldr) == 0) && (pn512_fifo_length(pPN512) > 0)) {
-    {
             //Stop command
             pn512_cmd_exec(pPN512, PN512_CMD_IDLE);
             pPN512->transceive.mode = pn512_transceive_mode_idle;
@@ -348,19 +315,16 @@ void pn512_transceive_hw_rx_task(uint32_t events, void* pUserData)
             return; //overflow
         }
 
-    if( irqs & PN512_IRQ_HIGH_ALERT )
+        if (irqs & PN512_IRQ_HIGH_ALERT) {
-    {
             NFC_DBG("High alert");
             pn512_irq_clear(pPN512, PN512_IRQ_HIGH_ALERT);
         }
 
-    if( irqs & PN512_IRQ_RX )
+        if (irqs & PN512_IRQ_RX) {
-    {
             pn512_irq_clear(pPN512, PN512_IRQ_RX);
 
             size_t last_byte_length = pn512_register_read(pPN512, PN512_REG_CONTROL) & 0x7;
-      if( last_byte_length == 0 )
+            if (last_byte_length == 0) {
-      {
                 last_byte_length = 8;
             }
             pPN512->readLastByteLength = last_byte_length;
@@ -371,11 +335,9 @@ void pn512_transceive_hw_rx_task(uint32_t events, void* pUserData)
             NFC_DBG("Received:");
             DBG_BLOCK(buffer_dump(buffer_builder_buffer(&pPN512->readBufBldr));)
 
-      if( (pPN512->transceive.mode == pn512_transceive_mode_target_autocoll) || (pPN512->transceive.mode == pn512_transceive_mode_transmit_and_target_autocoll) )
+            if ((pPN512->transceive.mode == pn512_transceive_mode_target_autocoll) || (pPN512->transceive.mode == pn512_transceive_mode_transmit_and_target_autocoll)) {
-      {
                 //Check if target was activated
-        if( !(pn512_register_read(pPN512, PN512_REG_STATUS2) & 0x10) )
+                if (!(pn512_register_read(pPN512, PN512_REG_STATUS2) & 0x10)) {
-        {
                     pPN512->transceive.mode = pn512_transceive_mode_idle;
 
                     pn512_irq_set(pPN512, PN512_IRQ_NONE);
@@ -386,27 +348,21 @@ void pn512_transceive_hw_rx_task(uint32_t events, void* pUserData)
                 }
                 //PN512 switches to transceive automatically
                 pPN512->transceive.mode = pn512_transceive_mode_transceive;
-      }
+            } else if (pPN512->transceive.mode == pn512_transceive_mode_receive) {
-      else if( pPN512->transceive.mode == pn512_transceive_mode_receive )
-      {
                 pPN512->transceive.mode = pn512_transceive_mode_transceive;
                 //pn512_cmd_exec(pPN512, PN512_CMD_IDLE); //Useful?
             }
 
-      if(!collision_detected)
+            if (!collision_detected) {
-      {
                 pn512_transceive_callback(pPN512, NFC_OK);
-      }
+            } else {
-      else
-      {
                 pn512_transceive_callback(pPN512, NFC_ERR_COLLISION);
             }
 
             return;
         }
     }
-  if( irqs & PN512_IRQ_RF_OFF )
+    if (irqs & PN512_IRQ_RF_OFF) {
-  {
         //Stop command
         pn512_cmd_exec(pPN512, PN512_CMD_IDLE);
         pPN512->transceive.mode = pn512_transceive_mode_idle;
@@ -439,31 +395,24 @@ void pn512_transceive_hw(pn512_t* pPN512, pn512_transceive_mode_t mode, pn512_cb
     //Clear previous IRQs if present
     pn512_irq_clear(pPN512, PN512_IRQ_RX | PN512_IRQ_TX | PN512_IRQ_HIGH_ALERT | PN512_IRQ_LOW_ALERT | PN512_IRQ_ERR | PN512_IRQ_IDLE | PN512_IRQ_RF_OFF);
 
-  if( PN512_FRAMING_IS_TARGET(pPN512->framing) )
+    if (PN512_FRAMING_IS_TARGET(pPN512->framing)) {
-  {
         //RF off?
-    if(!(pn512_register_read(pPN512, PN512_REG_STATUS1) & 0x04))
+        if (!(pn512_register_read(pPN512, PN512_REG_STATUS1) & 0x04)) {
-    {
             //Call callback
             pn512_transceive_callback(pPN512, NFC_ERR_FIELD);
             return;
         }
-  }
+    } else if ((pPN512->transceive.mode != mode) && (mode == pn512_transceive_mode_transceive)) {
-  else if((pPN512->transceive.mode != mode) && (mode == pn512_transceive_mode_transceive))
-  {
         pn512_cmd_exec(pPN512, PN512_CMD_TRANSCEIVE);
     }
 
     pPN512->transceive.mode = mode;
 
-  if( mode == pn512_transceive_mode_receive )
+    if (mode == pn512_transceive_mode_receive) {
-  {
         pn512_cmd_exec(pPN512, PN512_CMD_IDLE);
         pn512_transceive_hw_rx_start(pPN512);
         pn512_cmd_exec(pPN512, PN512_CMD_TRANSCEIVE);
-  }
+    } else if (mode == pn512_transceive_mode_target_autocoll) {
-  else if(mode == pn512_transceive_mode_target_autocoll)
-  {
         //Make sure bitframing reg is clean
         pn512_register_write(pPN512, PN512_REG_BITFRAMING, 0x00);
 
@@ -472,16 +421,13 @@ void pn512_transceive_hw(pn512_t* pPN512, pn512_transceive_mode_t mode, pn512_cb
         //Start autocoll
         pn512_cmd_exec(pPN512, PN512_CMD_AUTOCOLL);
         return;
-  }
+    } else {
-  else
-  {
         NFC_DBG("Sending:");
         DBG_BLOCK(buffer_dump(&pPN512->writeBuf);)
 
         //Transmit a frame to remote target/initiator
         irqs_en = PN512_IRQ_TX | PN512_IRQ_IDLE;
-    if( PN512_FRAMING_IS_TARGET(pPN512->framing) )
+        if (PN512_FRAMING_IS_TARGET(pPN512->framing)) {
-    {
             irqs_en |= PN512_IRQ_RF_OFF;
         }
 

features/nfc/stack/transceiver/pn512/pn512_types.h

@@ -27,8 +27,7 @@
 extern "C" {
 #endif
 
-typedef struct __pn512_registers
+typedef struct __pn512_registers {
-{
     int8_t registers_page;
 } pn512_registers_t;
 

features/nfc/stack/transceiver/protocols.h

@@ -34,8 +34,7 @@
 extern "C" {
 #endif
 
-typedef enum __RF_PROTOCOL
+typedef enum __RF_PROTOCOL {
-{
     __RF_PROTOCOL_UNKNOWN = 0,
     //Reader
     RF_PROTOCOL_ISO_14443_A_READER,
@@ -67,8 +66,7 @@ typedef uint32_t RF_OPTION;
 #define RF_OPTION_CHECK_PARITY    0x08
 #define RF_OPTION_CLOSE           0x10 //Last frame
 
-typedef enum __RF_BITRATE
+typedef enum __RF_BITRATE {
-{
     RF_BITRATE_106K = 0x00,
     RF_BITRATE_212K = 0x01,
     RF_BITRATE_424K = 0x02,

features/nfc/stack/transceiver/transceiver.h

@@ -51,8 +51,7 @@ enum __nfc_framing {
     nfc_framing_initiator_f_424,
 };
 
-typedef struct __nfc_tech
+typedef struct __nfc_tech {
-{
     unsigned int nfc_type1 : 1;
     unsigned int nfc_type2 : 1;
     unsigned int nfc_type3 : 1;
@@ -64,8 +63,7 @@ typedef struct __nfc_tech
 } nfc_tech_t;
 
 typedef struct __polling_options polling_options_t;
-struct __polling_options
+struct __polling_options {
-{
     unsigned int bail_at_first_target : 1;
     unsigned int bail_at_first_tech : 1;
     int32_t listen_for;
@@ -89,8 +87,7 @@ typedef void (*abort_fn_t)(nfc_transceiver_t* pTransceiver);
 typedef void (*close_fn_t)(nfc_transceiver_t *pTransceiver);
 typedef void (*sleep_fn_t)(nfc_transceiver_t *pTransceiver, bool sleep);
 
-struct __transceiver_impl
+struct __transceiver_impl {
-{
     set_protocols_fn_t set_protocols;
     poll_fn_t poll;
     set_crc_fn_t set_crc;
@@ -109,8 +106,7 @@ struct __transceiver_impl
 };
 
 typedef struct __nfc_a_info nfc_a_info_t;
-struct __nfc_a_info
+struct __nfc_a_info {
-{
     uint8_t uid[10];
     size_t uidLength;
     uint8_t sak;
@@ -118,23 +114,20 @@ struct __nfc_a_info
 };
 
 typedef struct __nfc_b_info nfc_b_info_t;
-struct __nfc_b_info
+struct __nfc_b_info {
-{
     uint8_t pupi[4];
     uint8_t application_data[4];
     uint8_t protocol_info[3];
 };
 
 typedef struct __nfc_f_info nfc_f_info_t;
-struct __nfc_f_info
+struct __nfc_f_info {
-{
     uint8_t nfcid2[8];
 };
 
 typedef struct __nfc_info nfc_info_t;
 
-struct __nfc_info
+struct __nfc_info {
-{
     nfc_tech_t type;
     union {
         nfc_a_info_t nfcA;
@@ -144,8 +137,7 @@ struct __nfc_info
 };
 
 #define MUNFC_MAX_REMOTE_TARGETS 4
-struct __transceiver
+struct __transceiver {
-{
     const transceiver_impl_t *fn; //vtable
 
     bool initiator_ntarget;
@@ -255,8 +247,7 @@ static inline nfc_scheduler_t* transceiver_get_scheduler(nfc_transceiver_t* pTra
 
 static inline const nfc_info_t *transceiver_get_remote_target_info(nfc_transceiver_t *pTransceiver, size_t number)
 {
-  if( number > pTransceiver->remote_targets_count )
+    if (number > pTransceiver->remote_targets_count) {
-  {
         return NULL;
     }
     return &pTransceiver->remote_targets[number];